[Kotlin] 코틀린 기초 (feat. 함수, 클래스, Null 등...)

함수

1. 유닛 반환 타입(Unit Return Type): 반환값 없는 함수에 대한 타입 표현, 생략 가능
2. 기본 인수(Default Arguments): 함수 매개변수에 기본값 설정으로 함수 오버로딩 필요성 감소
3. 명명된 인수(Named Arguments): 매개변수 이름을 통한 인수 전달로 인수 순서 자유로움
4. 단일 표현식 함수(Single Expression Functions): 함수 본문 축약 표현으로 코드 간결성 향상

package fastcampus.part0.kotlin

fun main() {
    println("Hello")
    test1(1, 2)
    test1(1, 3)

    test2(1)
    test2(l = 1, n = 3)

    // 2-3. 함수 안에서 선언 값에 대해 작성 가능 (순서 무관)
    info1(id = "1three", name = "스리", nickname = "Three")
    info2("스리", "Three", "1three")
}

// 2. 함수 : fun
// 2-1. 반환 타입 : 반환 타입이 없을 경우 Unit (생략 가능)
fun test1(n: Int, m: Int) {
    println("$n, $m")
}

// 2-2. 오버로딩 필요 X : 매개변수 m의 default value 4로 설정 가능
fun test2(n: Int, m: Int = 4, l: Int = 5): Int {
    println("$n, $m, $l")
    return n + m
}

fun info1(name: String, nickname: String, id: String) {
    println("$name, $nickname, $id")
}

// 2-4. Single Expression (단일 표현식) : 함수 정의 축약
fun info2(name: String, nickname: String, id: String) = println("$name, $nickname, $id")

 

변수

package fastcampus.part0.kotlin

fun main() {
    // 3. 변수
    // val 상수
    // var 변수
    var a: Int = 3
    val b: Int = 10
    a = 4

    val name = "한슬" // 타입 추론
}

 

클래스

1. 클래스 생성자(Constructor): 클래스 인스턴스를 생성할 때 호출되는 함수, 매개변수에 기본값 설정 가능
2. 접근 제어자(Access Modifiers): 클래스 멤버의 접근 범위를 제한, private 키워드로 비공개 설정
3. 상속(Inheritance): 클래스의 특성을 재사용하고 확장하기 위한 기능, open 키워드로 상속 허용
4. 주 생성자(Primary Constructor): 클래스 헤더에 선언되며, 클래스 인스턴스 생성 시 호출
5. 부 생성자(Secondary Constructor): 클래스 본문에 선언되며, 주 생성자 외의 추가적인 생성자
6. 초기화 블록(Init Block): 클래스 인스턴스 초기화 과정에서 실행되는 코드 블록
7. 오버라이딩(Overriding): 상속받은 멤버의 기능을 자식 클래스에서 재정의, override 키워드 사용

package fastcampus.part0.kotlin

fun main() {
    val user = User("한슬", 24)
    user.age = 26
    // user.name : 접근 불가 (private)
    println(user.age)

    Kid("아이", 3, "male")
}

// 4. 클래스
// 4-1. () : Constructor(생성자)
// 4-2. Constructor : default value 설정 가능
class User(private val name: String, var age: Int = 24)

// 4-3. 상속 : open 키워드 사용
// Kid 생성 시, User2 상속 받고 싶을 경우
open class User2(open val name: String, open var age: Int = 24)

// 바깥 : 주 생성자
class Kid(override val name: String, override var age: Int) : User2(name, age) {
    var gender: String = "female"

    // 클래스 내 가장 먼저 호출
    init {
        // Fragment 초기화 시 사용
        println("초기화 중")
    }

    // 내부 : 부 생성자
    constructor(name: String, age: Int, gender: String) : this(name, age) {
        this.gender = gender
        println("부 생성자 호출")
    }
}

 

조건식

package fastcampus.part0.kotlin

fun main() {
    max(10, 3)
    min(10, 3)
    isHoliday("월")
}

// 5-1. if
fun max(n: Int, m: Int) {
    // result : kotlin.Unit
    val result = if (n > m) println("큰 수는 $n")
    else if (n < m) println("큰 수는 $m")
    else println("$n = $m")

    println(result)
}

fun min(n: Int, m: Int) {
    val result = if (n > m) "작은 수는 $m" else if (n < m) "작은 수는 $n" else "$n = $m"

    println(result)
}

// 5-2. when
fun isHoliday(dayOfWeek: Any) {
    val result = when (dayOfWeek) {
        "토", "일" -> if (dayOfWeek == "토") "토요일 좋아 :)" else "내일 월요일..."
        in listOf("월", "화") -> "버티자"
        in 2..4 -> "숫자의 경우, 범위 값으로 사용 가능"
        else -> false
    }

    println(result)
}

 

반복문

package fastcampus.part0.kotlin

fun main() {
    // 6-1. for

    // 1..10 == IntRange(1, 10) == 1 until 11
    for (i in 1..10) {
        print("$i ")
    }
    println()

    for (i in IntRange(1, 10)) {
        print("$i ")
    }
    println()

    for(i in 1 until 11) {
        print("$i ")
    }
    println()

    for(i in 10 downTo 1) {
        print("$i ")
    }
    println()

    for(i in 1..10 step 2) {
        print("$i ")
    }
    println()

    for(i in 10 downTo 1 step 2) {
        print("$i ")
    }
    println()

    // 6-2. while
    var j = 1

    while(j < 11) {
        print("$j ")
        j++
    }
}

 

컬렉션

package fastcampus.part0.kotlin

fun main() {
    // 7-1. list
    // mutableList : 추가, 삭제 등 변경 가능
    // list : 변경 불가

    val list = mutableListOf(1, 2, 3, 4, 5)
    list.add(6)
    list.addAll(listOf(7, 8, 9))

    val list2 = listOf(1, 2, 3, 4)
    // list2.add // Error

    println(list)
    println(list2.joinToString(" ")) // it 사용

    // 특징 1 : 다양한 타입 저장
    val diverseList = listOf(1, "hi", 3.14, true)

    // 특징 2 : 강력한 확장 함수
    // first, map 등

    // 7-2. map
    val map = mapOf((1 to "안녕"), (2 to "Hello"))
    // map.put // Error

    val map2 = mutableMapOf((1 to "안녕"), (2 to "Hello"))
    // map2.put(3, "Bonjour")
    map2[3] = "Bonjour" // Index Operator
}

 

Null

1. Null 안정성: 코틀린은 기본적으로 모든 타입의 변수가 null을 가질 수 없도록 설계되어, NullPointer 예외 방지
2. Nullable 타입: ?를 타입 뒤에 붙여 null을 가질 수 있는 변수로 선언
3. Elvis 연산자(Elvis Operator?:): 왼쪽 피연산자가 null이 아니면 그 값을, null이면 오른쪽 피연산자의 값을 반환
4. Safe Call Operator(?.): null이 아닌 경우 해당 연산을 수행하고, null인 경우 null을 반환
5. Non-null Assertion Operator(!!.): null이 아님을 확신할 때 사용하며, null인 경우 NullPointer 예외 발생

package fastcampus.part0.kotlin

fun main() {
    // 8. null (Kotlin의 null 안정성)

    // 타입 선언 : null 불가 명시
    // : String
    // : Int
    var name: String = "한슬"
    // name = null // 컴파일 단계 Error

    // 타입? 선언 : null 가능 명시
    // : String?
    // : Int?
    var nickname: String? = "three"

    /*
    * Elvis Operation (?:)
    *
    * 왼쪽 값이 non-null 경우, 객체 값 리턴
    * 왼쪽 값이 null 경우, 오른쪽 값 리턴
    */

    // val result = if (nickname == null) "값 X" else nickname
    val result = nickname ?: "값 X"
    println(result)

    nickname = null
    // val nicknameLength = nickname.length // Error

    // ? : null 경우, null 반환
    // !! : null 아님이 확실할 경우
    val nicknameLength = nickname?.length

    println(nicknameLength)
}

 

타입 체크와 캐스팅

1. 타입 체크(Type Check): is 키워드를 사용하여 변수의 타입을 확인
2. 캐스팅(Casting): as 키워드를 사용하여 변수의 타입을 변환
3. 세이프 캐스트(Safe Cast): as? 키워드를 사용하여 변환 불가능한 경우 null을 반환
4. 스마트 캐스트(Smart Cast): is 키워드를 사용하여 타입 체크 후, 해당 타입으로 자동 변환되어 사용
5. 엘비스 연산자(Elvis Operator): ?: 키워드를 사용하여 null인 경우 대체 값 제공

package fastcampus.part0.kotlin

fun main() {
    // 9-1. 타입 체크 : is
    println(checkType("Hi"))
    println(checkType(3))
    println(checkType(true))

    // 9-2. 캐스팅 (형 변환) : as
    cast("안녕")
    // cast(10) // ClassCastException (Int → 불가 → String)

    println(smartCast("안녕"))
    println(smartCast(10))
    println(smartCast(true))
}

fun checkType(n: Any): String {
    return when (n) {
        is String -> "문자열"
        is Int -> "정수"
        else -> "몰라"
    }
}

fun cast(m: Any) {
    // as? Type : Type으로 변환 불가 시, 자동 null 반환
    // val result = m as? String
    // val result = (m as? String) ?: "실패"
    val result = m as String

    println(result)
}

fun smartCast(l: Any): Int {
    return when (l) {
        is String -> l.length
        is Int -> l.dec() // dec = -1
        else -> -1
    }
}

 

String template

package fastcampus.part0.kotlin

fun main() {
    // 10. string template
    val n = 10
    val name = "three"
    val isTrue = true

    println("$n $name ${name.length} $isTrue")
}