Kotlin_기본 개념

1. Kotlin이란?

• JetBrains 사에서 만든 프로그래밍 언어로서, JVM 기반으로 실행되어 JAVA와 100% 호환 가능하고, JAVA보다 간결한 문법 및 생산성을 높여주는 문법적 편의성을 제공한다.

• 최근에는 안드로이드 공식 언어로 채택되었고, 웹 개발에서도 사용되는 추세이다.

• 객체 지향 프로그래밍과 함수형 프로그래밍이 가능하여, 함수를 변수에 담을 수 있고, 함수의 파라미터로 함수를 넘겨줄 수도 있다. -> 고차 함수

//코틀린은 함수형 언어이므로, Lambda식 접근이 편리
btn.setOnClickListener(new View.OnClickListener() {
  	@Override
    public void onClick(View v) {
        //실행 구문
    }
})

btn.setOnClickListener { v ->
    //실행 구문
}

2. 기본적인 함수 및 변수 선언

    fun main() {
        println("Hello, world!!!")
    }

    //코틀린 구문식 함수
    fun sum(a: Int, b: Int) : Int {
        return a + b
    }

    //코틀린 표현식 함수
    fun sum(a: Int, b: Int) = a + b

    fun max(a: Int, b: Int) = if(a>b) a else b

    //명시적 데이터 타입 선언
    val a: Int = 1

    //타입 추론
    val b = 2
    val c = 3.14

    //Null Safe로 인해 반드시 초기 값 설정 필요
    //val : 상수이기 때문에 두 번 이상의 초기화 불가능
    val d: String
    d = "기본 값"

    //Nullable
    val boolNull : Boolean? = null
    
    val b: Int? = 100
    val c: Int = 100

    b?.sum() //null일 경우 실행하지 않는다.
    c.sum() //변수 선언 때부터 nullsafe
    
    //초기값이 없는 전역 변수 선언
    lateinit var num: Int

    //추후 초기화
    num = 10

    //실제로 변수가 사용되기 전까지는 100이라는 값이 할당되지 않는다.
    val lazyNum : Int by lazy {
        100
    }

    //사용할 때 100 할당
    lazyNum.add()

• 일반 구문식 함수 선언과 달리 더 간결한 표현식 함수 선언이 가능하다.

• 타입 추론 : 코틀린은 자바와 달리 변수의 타입을 개발자가 직접 명시할 필요가 없다.

• Nullable : 코틀린은 null이 될 수 있는 타입을 '?'을 통해 명시할 수 있어 Null Pointer Exception에 따른 검사를 통해 신뢰성을 높일 수 있다.

• lateinit var : 초기 값이 없는 전역 변수 선언

• lazy : 호출 시점 한번 초기화를 진행하고, 그 이후에는 가져다가 쓰기만 한다.

• 이러한 함수 표현, 타입 추론 및 Nullable 검사를 통해 JAVA 기반 개발보다 짧고 안정적인 코드 생산이 가능하다.

3. 반복문 및 경우 처리

    //기본 반복문
    for(i in 1..5) {
        println(i)
    }

    //6 4 2 0
    for(i in 6 downTo 0 step 2) {
        println(i)
    }

    //1 4
    for(i in 1..5 step 3) {
        println(i)
    }

    //100 200 300
    val numberList = listOf(100, 200, 300)
    for (num in numberList) {
        println(number)
    }

    //sum에 1부터 9까지 축적 (until은 마지막 숫자 제외)
    var sum = 0;
    for(i in 1 until (10)) {
        sum += i
        println("$i")
    }

    //5 4 3 2 1
    var x = 5
    while(x>0) {
        println(x)
        x--
    }

    //0
    var y = 0
    do {
        print(y)
        y--
    } while (y>0)

    //표현식 if 구문
    val max = if(a>b) {
        print("Choose a")
    } else {
        print("Choose b")
    }

    when (x) {
        1 -> print("X==1")
        2 -> print("X==1")
        else -> {
            print("x is neither 1 nor 2")
        }
    }

    when (x) {
        0, 1 -> print("X==1 or X==2")
        else -> print("otherwise")
    }

    when (x) {
        in 1..10 -> print("x는 1부터 10 범위 안에 존재")
        !in 11..20 -> print("x는 11부터 20 범위 안에 없다.")
        else -> print("otherwise")
    }

    when (x) {
        is Int -> print("X는 정수형")
        else -> print("X는 정수형이 아니다.")
    }

4. Scope Function

• 객체의 Context내에서 코드의 블록을 실행하는 것이 유일한 목적인 함수.

• 코드의 기능을 정리하고 표현하여 가독성을 높인다.
  

1. Apply

• 객체 확장 함수, 객체의 초기화에 사용하며, this 생략 가능

    val person = Person().apply {
        firstName = "Lee"
        lastName = "Park"
    }

2. Also

• 객체를 파라미터를 통해 전달 (기본 파라미터 : it)

• 해당 파라미터는 Lambda의 입력 값으로 지정

    //1~100까지의 함수를 랜덤으로 추출하여 그 값을 파라미터로 print() 함수에 전달
    Random.nextInt(100).also {
        print("$it")
    }

    //파라미터명을 임의로 지정
    Random.nextInt(100).also { value ->
        print("$value")
    }

3. Let

• Null이 아닌 객체에서 Lambda 구문 실행

    val sumNumberStr = number?.let {
        //변수가 null이 아닐때 실행될 내용이 sumNumberStr에 삽입되는 것
        "${sum(10, it)}"
    }

    //orEmpty() : 변수가 null이면 빈 값 삽입
    val sumNumberStr = number?.let {
        "${sum(10, it)}"
    }.orEmpty()

4. With

• 상위 생성자를 통해 하위 함수를 실행하겠다고 명시한다.

• 확장 함수로 사용 불가

val person = Person()

With(person) {
    work()
    sleep()
    println(age)
}

5. Run

• 값에 대한 초기화 및 게산이 함께 있을 시 유용하다.

• 지역변수의 범위 제한에 사용

• 확장 함수로 사용 가능

val result = service.run {
    port = 8080
    query()
}