[📱|App] 헷갈리는 Kotlin 문법 정리

Jetpack Compose를 활용한 안드로이드 애플리케이션 개발을 시작할 때, 코틀린의 세련된 문법을 먼저 정리하고 들어가면 도움이 됩니다. 특히 다른 언어와 차별화되는 헷갈릴 수 있는 부분들을 위주로 정리해 보았습니다.

웹으로 접속 가능한 코틀린 playground에서 직접 컴파일 해보면서 공부해보세요!
https://play.kotlinlang.org

변수 선언

• 일반 규칙

  • 모든 변수는 객체를 가리키는 레퍼런스!
  • var, val 사용
    • val로 선언했다고 객체의 맴버 값도 변경할 수 없는 것은 아님 → c++의 const와 다름
  • 타입 명시와 추론
    • var data: Int = 10 ← 이렇게 타입을 명시 가능
    • 대입을 통해 추론 가능하다면 생략 가능
      • var a; a = 10; ← 불가능
      • var a: Int; a = 10; ← 가능

• 초기값 할당

  • 2가지 경우
    • 함수 내부 → 초기값 할당 필수 아님
      • 그러나 초기화 되지 않은 변수를 출력 등으로 사용하려고 하면 error
    • 최상위 선언, 클래스 속성으로 선언 → 초기값 할당 필수
  • 초기화 미루기
    • lateinit 키워드
      • 2가지 조건에 충족된다면, lateinit var a: String ← 가능
        1. var 키워드로 선언될 것
        2. primitive type이 아닐 것
    • lazy 키워드
      • val name: String by lazy { } ← 이렇게 사용되는 시점에 초기화 가능
      • { } 내부에 명시된 것들이 하나씩 실행되고 마지막 값으로 초기화
        • val a: Int by lazy { 10; 20; 30 } ← 30으로 초기화

데이터 타입

• primitive type ← Class로 제공됨

  • Byte(1byte), Short(2byte), Int(4byte), Long(8byte), Double, Float, Boolean
    • 이때 숫자를 나타내는 타입은 추상 클래스 Number 상속
  • var a: Int = 10, var b: Double? = null ← 가능

• 문자와 문자열

  • Char 타입은 Number를 상속하지 않음 → 계산 등에 사용될 수 없음
  • String 타입은 따옴표, 삼중따옴표로 표현
    • 문자열 탬플릿: "plus: ${a + 10 + pi()}", "plus: $a" ← 이렇게 가능

• Any, Unit, Nothing

  • Any: 최상위 클래스로 모든 클래스 가리킬 수 있음
    • 내가 새로 정의한 class도 반드시 자동으로 Any를 상속하게 됨
  • Unit: return이 없다는 것을 명시적으로 나타내기 위한 클래스
    • Unit으로 선언된 변수에는 Unit 빼고 어느 것도 담길 수 없음
      • Unit 인스턴스는 싱글톤, final 키워드로 상속도 막혀있음
  • Nothing: null만을 담기 위한 클래스, return이 항상 null일 때 사용
    • var a: Nothing? = null ← null을 제외한 그 무엇도 담지 못함
    • 만약 함수의 return 타입이 그저 Noting이라면 반드시 Exception을 던져야함

함수 선언

• fun add(a: Int, b: Int): Int

  • 파라미터는 var, val 타입을 사용할 수 없음 → 자동으로 반드시 val
    • 따라서 기타 언어와 달리 파라미터 변수의 값을 수정할 수 없음
  • return 타입 명시하지 않을 시, Unit으로 간주

• fun add(a: Int, b: Int, isDeciaml: Boolean = true): Int

  • 파라미터의 기본 값을 지정할 수 있음 → 이 경우 함수호출 시 해당 파라미터는 사용하지 않아도 됨
  • 기본 값이 지정된 파라미터가 반드시 가장 뒤에 모여있을 필요는 없음
    • 단, 이 경우 함수 호출 시 가독성이 떨어질 수 있음 → val result1 = add(5, b = 10)
      • named parameter

Collection Type

• Array

  • 기본
    • val data1: Array<Int> = Array(3, {0}) ← 기본적으로 제네릭으로 나타냄
      • 이때 {0} 는 람다식으로 val data: Array<Int> = Array(3) { 1 } ← 이 경우 모두 1로 초기화 됨
    • [idx], get(idx), set(idx, value) ← 이런식으로 접근 가능
    • val data = arrayOf<Int>(10, 20, 30) ← 이런 식으로 제네릭 함수를 통해 초기화도 가능
  • primitive type에 대해서
    • 기초 타입은 자주 사용하므로 클래스로 표현되어있음
      • BooleanArray, ByteArray, CharArray, IntArray, etc…
      • val data: IntArray = IntArray(3, {0}), val data = intArrayOf(1, 2, 3)

• List, MutableList

  • 순서가 있는 데이터 집합, 데이터 중복 허용
    • 불변과 가변으로 분류됨 → 불변 리스트는 초기화 이후 값 수정, 추가, 삭제 불가능
  • val data: List<Int> = List<Int>(3, {0}), val data = listOf<Int>(1, 2, 3)
    • mList.add(1), mList.add(3, 1), mutableList.set(2, 9), mutableList[2] = 1

• Set, MutableSet

  • 순서가 없으며, 데이터 중복을 불허용
    • 불변과 가변으로 분류됨

• Map, MutableMap

  • 키와 값으로 이루어진 데이터 집합, 순서가 없고, 키의 중복은 불허용
    • 불변과 가변으로 분류됨
  • 사용 예시
    • var map = mapOf<String, String>(Pair("one", "1"), "two" to "2")
      • map.get("one")

조건문

• if ~ else

  • 기존의 언어들과 사용법은 동일
  • 계산식(표현식)으로도 사용 가능 → 삼항 연산자 없음
    • var res = if (data > 0) { print("p"); true; } else { print("f"); false; }

• when

  • switch 역할을 수행하는 것, if ~ else 처럼 표현식으로도 사용 가능(이 경우 else 반드시 명시)
  • 사용 예시
    • ( ) 내에 data를 명시하면 다음과 같은 것들이 가능

      when (data) {
          "hello" -> println("data is hello")
          "world" -> println("data is world")
          else -> println("data is not valid data")
      }
      
      when (data) {
          is String -> println("data is String")
          20, 30 -> println("data is 20 or 30")
          in 1..10 -> println("data is 1..10")
          else -> println("data is not valid data")
      }

    • ( )를 생략하는 경우 조건문을 작성할 수 있음

      when {
          data <= 0 -> println("data is <= 0")
          data > 100 -> println("data is > 100")
          else -> println("data is not valid")
      }
      
      val result = when {
          data <= 0 -> "data is <= 0"
          data > 100 -> "data is > 100"
          else -> "data is not valid"
      }
      

반복문

• for

  • 원래처럼도 쓸 수 있지만 다음과 같이 활용할 수도 있음
    1. for (i in 1 .. 10) { … } ← 1 부터 10까지
    2. for (i in 1 until 10) { … } ← 1부터 9까지
    3. for (i in 2 .. 10 step 2) { … } ← 2부터 10까지 2씩 증가
    4. for (i in 1 downTo 10) { … } ← 10부터 1까지 1식 감소
    5. for (i in arrayOf<Int>(0, 1, 2).indices) { … } ← 컬렉션 타입 데이터 반복
    6. for ((index, value) in arrayOf<Int>(0, 1, 2).withIndex()) { … }

• while

  • 다른 언어와 동일하게 동작

Class

• 클래스 선언

  • 클래스의 맴버는 생성자(주, 보조), 변수, 함수, 클래스로 구성됨
    • 모든 맴버 변수는 생성자에서 반드시 초기화할 것, 혹은 lateinit 키워드 사용
  • 클래스 내에 다른 클래스 선언 가능
  • 인스턴스를 생성할 때 new 키워드 사용하지 않음
    • val user = User("minseok128")
  • 생성자(주 생성자, 보조 생성자)
    • 주 생성자만 선언, 보조 생성자만 선언, 둘 다 선언 모두 가능

• 주 생성자

  • 주 생성자 선언의 여러 형태
    1. 우선 클래스명 뒤에 다음과 같은 방법으로
       1. class User constructor() { } ← class 명칭 뒤에 constructor() 명시 형태
       2. class User() { } ← constructor 생략 형태
    2. init { } 을 사용하여 주 생성자의 본문 작성 가능
       • 선택적 구현
    3. 주 생성자 매개변수를 즉시 클래스 맴버 변수로 변환
       1. class User(val name: String, private var count: Int) ← 즉시 맴버로 선언
       2. class User(name: String, count: Int) ← 매개변수 오직 init 내에서만 접근 가능
  • 코틀린 클래스는 주생성자 기준으로 동작!

• 보조 생성자

  • 클래스 본문에 constructor 키워드로 선언하는 함수 → 다른 매개변수로 여러 개 선언 가능
    • 예시

      class User {
          constructor(name: String) {
              println("first constructor")
          }
          
          constructor(name: String, count: Int) {
              println("second constructor")
          }
      }

    • 만약 val 키워드로 선언된 맴버 변수를 생성 시점에 특정 값으로 초기화하고 싶다면
      → 반드시 주 생성자를 호출하는 식으로 진행해야함
  • 만약 주 생성자가 존재한다면? → 모든 보조 생성자는 어떤 식으로든 this() 통해 주생성자를 호출
    • 예시

      class User(name: String) {
          init {
              println("main constructor")
          }
      
          constructor(name: String, count: Int): this(name) {
              println("first constructor")
          }
      
          constructor(name: String, count: Int, email: String): this(name, count) {
              println("second constructor")
          }
      }

    • 주생성자가 없다면 호출했다고 침

• 상속과 생성자

  • 부모
    • open class Animal(val name: String) { } ← 반드시 open 키워드 명시
  • 자식
    • 주생성자 호출하 듯 반드시 부모의 생성자를 호출할 것

      open class Animal(val name: String) {}
      
      class Sub1(name: String): Animal(name) {}
      
      class Sub2 {
      	constructor(name: String): super(name) { }
      }

      • 주 생성자가 있다면 상속 시점에서 부모의 매개변수를 적절히 넘겨줘야만 함
      • 주 생성자가 없다면 보조 생성자에서 super를 통해 호출할 수 있음

• 오버라이딩

  • 부모
    • 오버라이딩을 허용하는 변수와 함수 선언문 앞에 반드시 open 키워드 명시
  • 자식
    • 재정의하기 위해 선언문 앞에 override 키워드 명시
  • 변수를 오버라이딩 하는 이유 → 모든 맴버 변수는 초기화되어야함 → 부모 값을 바꾸려면 재정의 뿐
    • var 키워드로 선언된 변수도 재정의 가능

• 접근 제한자

  • 접근 제한자가 생략된 경우 → public을 의미
  • 2가지 상황에서 다른 의미로 사용
    • 파일의 최상위에서 사용
      • public: 모든 파일에서 가능
      • internal: 같은 모듈 내에서 가능
      • protected: 사용 불가
      • private: 파일 내부에서만 사용 가능
    • 클래스 맴버에 대해서 사용
      • public: 모든 클래스에서 가능
      • internal: 같은 모듈 내에서 가능
      • protected: 상속 관계의 하위 클래스에서 가능
      • private: 클래스 내부에서 가능

다양한 클래스

• 데이터 클래스

  • 데이터를 표현하는데 목적있는 클래스 VO(value-object)라고도 불리움
    • data class DataClass(val name: String, val email: String, val age: Int)
  • 차이점: 일반 class와 거의 유사하지만 다른 점이 있음
    • equals 함수
      • 주 생성자의 맴버 변수들의 값이 동일하다면 true ← 원래는 동일한 객체인지를 확인
    • toString 함수
      • 주 생성자의 맴버 변수들을 나열한 String return ← 원래는 무의미한 값 출력

• 오브젝트 클래스

  • 익명 클래스를 만들 목적 → 그 타입은 Any로 취급
  • 주로 상위 클래스를 상속하여 다뤄짐

    open class Super {
        open var data = 10
        open fun some() {
            println("I am super some() : $data")
        }
    }
    
    val obj = object : Super() {
        override var data = 20
        override fun some() {
            println("I am object some() : $data")
        }
    }

• 컴패니언 클래스
  • static 맴버와 동일한 기능을 제공, 클래스 내부의 클래스로 선언

    class MyClass {
        companion object {
            var data = 10
            fun some() {
                println(data)
            }
        }
    }
    
    fun main() {
        MyClass.data = 20  // OK
        MyClass.some()     // OK
    }

다양한 함수

• 람다 함수

  • 익명 함수 정의 기법, 주로 고차함수의 매개변수 혹은 반환값으로 활용됨
  • 활용 예시
    • val sum = { a: Int, b: Int -> a + b } ← 이 경우 아래와 같이 타입이 추론됨
      • val sum: (Int, Int) -> Int = { a: Int, b: Int -> a + b }
    • println({ a: Int, b: Int -> a + b }(10, 20))
    • val sum = { a: Int, b: Int -> println("+"); a + b; } ← 마지막 표현식이 return
    • val func1 = { println("hi") } ← 매개변수 없는 경우 화살표 생략 가능
    • val func1: (Int) -> Unit = { println(it) } ← 매개변수 하나 it으로 표현, 화살표 생략

• 타입

  • 함수의 타입 선언
    • val some: () -> Int = { 42 }
  • 타입 별칭
    • typealias MyFunType = (Int, Int) -> Unit
    • 별칭을 따로 지정 가능
  • 함수 매개변수 타입 생략
    • 어떤 식으로든 추론 가능하면 생략 가능

      typealias MyFunType = (Int, Int) -> Boolean
      
      val someFun: MyFunType = { no1, no2 -> no1 > no2 }
      
      val someFun2: (Int, Int) -> Boolean = { no1, no2 -> no1 > no2 }
      
      val someFun3: (no1: Int, no2: Int) -> Boolean = { no1, no2 -> no1 > no2 }

• 고차 함수

  • 후행 람다 전달: 함수의 마지막 매개변수가 함수일 때 인수로 전달될 람다함수는 괄호 밖으로 배치 가능

    fun hotFun2(data: Int, arg: (Int) -> Boolean): Int {
        return if (arg(data)) 100 else 0
    }
    
    val result3 = hotFun2(10) {
        println("high order function")
        it > 50
    }
    
    println(result3)

• null 안전성 연산자
  • ?. 연산자 ← 널 허용으로 선언된 변수의 맴버에 접근하기 위해 사용, null을 return할 수 있음
  • ? 연산자 ← 변수가 null을 가질 수 있을 때 type 옆에 명시
  • !! 연산자 ← 객체가 null일 때 예외를 발생시킴, null은 허용하지만 오류는 발생

구현되어 있는 함수형 프로그래밍 함수

• forEach: 순회하면서 각 요소에 대해 action을 수행

  • public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit
  • 예시: listOf(1, 2, 3).forEach { println(it) }

• filter: 각 요소에 대한 predicate 함수의 return이 참인 요소들만 포함된 리스트를 생성

  • public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>
  • 예시: val even = listOf(1, 2, 3, 4).filter { it % 2 == 0 }

• partition: 각 요소에 대하 predicate 함수 결과로 분리된 2개의 리스트를 페어로 생성

  • public fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>
  • 예시: val (even, odd) = listOf(1, 2, 3, 4).partition { it % 2 == 0 }

• map: 각 요소에 대해 transform 함수가 적용된 결과로 이루어진 리스트를 생성

  • public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
  • 예시: val doubled = listOf(1, 2, 3).map { it * 2 }

• any: 요소들 중 predicate 함수가 참인 요소가 존재하면 true를 return

  • public inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean
  • 예시: val hasEven = listOf(1, 2, 3).any { it % 2 == 0 }

• reduce: 각 요소들에 operation을 적용하여, 하나의 값으로 만들고 return

  • public inline fun <S, T: S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S
  • 예시: val sum = listOf(1, 2, 3, 4).reduce { acc, num -> acc + num }

• distinct: 중복되는 요소가 제거된 리스트 반환

  • public fun <T> Iterable<T>.distinct(): List<T>
  • 예시: val unique = listOf(1, 2, 2, 3).distinct()

• find/findLast: 조건을 만족하는 가장 앞/뒤의 원소를 return, 없으면 null

  • public inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?
  • 예시: val firstEven = listOf(1, 2, 3).find { it % 2 == 0 }

• groupBy: 주어진 key에 맞게 키와 리스트로 이루어진 Map을 생성

  • public inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
  • 예시: val group = listOf("a", "bb", "ccc").groupBy { it.length }

• maxByOrNull/minByOrNull: selector 값이 가장 큰/작은 원소를 return, 없으면 null

  • public inline fun <T, R: Comparable<R>> Iterable<T>.maxByOrNull(selector: (T) -> R): T? public inline fun <T, R: Comparable<R>> Iterable<T>.minByOrNull(selector: (T) -> R): T?
  • 예시: val maxString = listOf("a", "bb", "ccc").maxByOrNull { it.length } val minString = listOf("a", "bb", "ccc").minByOrNull { it.length }