Kotlin - Kotlin 기초 초간단 정리

개요

이 글은 Java 문법이 익숙하고 Kotlin 문법이 헷갈리는 사람(나)를 위해 정리한 글이다.

아주 빠르게 훑어보자

 

변수

val a = 10 // Int 로 타입 추론
var b =  10
b = 20 // var 변수는 재할당 가능

 

null

var x: Int? = 10
x = null // ? 는 nullable 타입

 

?. !!.

var str: String? = null
println(str?.uppercase()) 
str = "abc"
println(str!!.uppercase())

 

function

fun add(x: Int, y: Int): Int {
        return x + y
}

fun add(x: Int, y: Int) = x + y // 리턴 타입 생략 + 한 줄 표현

 

기본 자료형

• 숫자형
  • Double
  • Float
  • Long
  • Int
  • Short
  • Byte

val a = 1 // Int - 기본
val b = 3000000000 // Long - 21억 초과 시 자동 Long
val c = 1L // Long - suffix L
val d: Byte = 1 // Byte - 쩔수 

val e = 3.14 // Double - 기본
// val f: Double = 1 // Error - type mismatch
val g = 3.1415926535 // Float - 6~7 자리 초과
val h = 3.14f // Float - suffix f

• 문자형
  • String
  • Char
  • longStr
• 배열
  • Array<타입>
  • arrayOf() // 생성과 동시 초기화

 

반복문

val numbers = arrayOf(1, 2, 3, 4, 5)
var sum = 0

for (n in numbers) {
        sum += n
}

print("sum : $sum")

for (i in 1 .. 10) { // 1 ~ 10
        println(i)
}
for (i 10 downTo 1) {
        println(i)
}
for (i in 1 .. 10 step 2) {
        println(i)
}
for (i in 1 until 10) { // 1 ~ 9
        println(i)
}

• while은 너무 똑같아 생략

 

조건문

• if문은 너무 똑같아 생략

val bigger = if (a>b) a else b // 바로 대입 가능

// java 의 switch case 문은 when 으로 대체
when (x) {
        1 -> println("일")
        5 -> println("오")
        else -> println("?")
}

// 마찬가지로 직접 대입 가능
val num = when (x) {
        1 -> "일"
        2 -> "이"
        3 -> "삼"
}

 

lateinit

lateinit var text: String // 굳이 null로 초기화해놓지 말고 lateinit 하자
val a = 1
text = "text $a"
val b = 2
text = "text $a $b"

• lateinit은 값이 계속 변경될 수 있다는 속성이라 반드시 var을 사용해야 하고,
• 숫자형(Int Float 등)에는 사용할 수 없다.

 

by lazy

lateinit var text: String
val textLength: Int by lazy {
        text.length
}
text = "asdf"
println(textLength)

• 선언 당시 초기화할 수 없지만, 호출 시 어떻게 초기화할지 정의해주는 것
• 따라서 val만 사용

 

클래스

인스턴스 생성

class Person {
}

fun main() {
        val person = Person() // new 필요 없음!!
}

 

프로퍼티 선언

class Person {
        var name: String = "" // 클래스 선언과 동시 초기화 필수
        var age: Int = 0
}

생성자 선언

class Person {
        constructor (name: String, age: Int) {
                this.name = name
                this.age = age
        }
        var name: String = ""
        var age: Int = 0
}

// 축약
class Person (name: String, age: Int) {
        var name: String = ""
        var age: Int = 0
}

// 기본 값 지정
class Person (name: String, age: Int = 20) {
        var name: String = name
        var age: Int = age
}
val p1 = Person("김인간") // age는 자동 20

// 한 줄로 또 축약 + 기본 값 지정
class Person (var name: String = "이름", var age: Int = 20)
val p2 = Person()

 

상속

open class Fruit {}
class Apple: Fruit() {} // Fruit 를 상속받은 Apple

• 상속 불가능이 default이기 때문에 open 필수!

 

내부 클래스

class Student {
    var name: String = "John"

    init {
        println("name : $name")
    }

    inner class Personality {
        fun doSomething(): Unit {
            name += ", the king of everything..."
            println(name)
        }
    }
}

fun main() {
    val student = Student()
    student.Personality().doSomething()
}

• inner 키워드를 붙여 클래스 내부에서 사용

 

컬렉션

List

• listOf() - 불변형 리스트, 원소 변경 불가

val list1: List<String> = listOf("one", "two")
        // 사실 List<String> 통째로 생략 가능 (타입 추론)
val list2 = listOf(1, "one", 2, "two")
        // Any 타입으로 추론됨

// 원소 접근
println("last el of list1 : ${list1[1]}")

// 원소 순회
for (el in list1) println(el)

• mutableListOf() - 가변형 리스트, add, remove, 변경 가능

val list3: MutableList<String> = mutableListOf<String>("one", "two")
        // 사실 타입 생략 가능
val list4 = mutableListOf("one", "two") // 이게 가장 축약된 버전
list4.add("three")
list4.removeAt(1)
list4[0] = "ONE"
println(list4) // [ONE, three]

Set

val set1: Set<Int> = setOf<Int>(1,2,3)
val set2 = setOf(1,2,3) // 축약

• 불변형 set - setOf()
• 가변형 set - mutableSetof() , hashSetOf() , sortedSetOf() , linkedSetOf()

Map

val map1: Map<Int, String> = mapOf(11 to "one", 22 to "two")
// 축약 생략
print(${map1[22]})
print(${map1.get(22)})
print(${map1.keys})

• 불변형 map - mapOf()
• 가변형 map - mutableMapOf() , hashMapOf() , sortedMapOf() , linkedMapOf()

 

참고문서

[Kotlin] 코틀린 기본문법1 (변수선언/함수선언/자료형/반복문/조건문)

[Kotlin] 코틀린 기본문법2 (NULL처리 : lateinit/lazy/!!/?/?.)

[Kotlin] 코틀린 기본문법3 (클래스와 컬렉션: List/Map/Set)