coroutine은 kotlin 언어를 쓰는 개발자들이 겪는 스레딩 문제를 직관적인 방식으로 해결 할 수 있는 기술 이다.

Corotuine은 LightWeight Thread 이다.

기존 자바의 async task 또는 rxjava 등 비동기 작업을 하기 위해서는 하나의 쓰레드를 생성해야 하는데,Coroutine은 쓰레드 스케쥴링 가능한 코드 블록 또는 코드블록들의 집합내에서 스위칭이 이뤄지기 때문에 OS단의 context switching이 일어나는게 아닌 Coroutine Object 객체들만이 스위칭함으로써 부하가 덜 생긴다.

Thread

• Task 단위 = Thread 다수의 작업 각각에 Thread를 할당 한다.

• Context Switching OS커널에 의한 Context Switching을 통해 동시성을 보장한다. Blocking: 작업 1(Thread) 이 작업 2(Thread) 의 결과가 나오기까지 기다려야한다면 작업 1 Thread 는 Blocking 되어 그 시간동안 해당 자원을 사용하지 못한다.

Coroutine

• Task 단위 = Obejct(Coroutine) 다수의 작업 각각에 Object를 할당 한다. 이 Coroutine Object는 객체를 담는 JVM Heap에 적재 된다.

• Progreammer Switching = No Context Switching 프로그래머의 코딩을 통해 Switching 시점을 마음대로 정함으로써 동시성을 보장한다. Suspend(Non_Blocking) : 작업 1(Object) 이 작업 2(Object) 의 결과가 나오기까지 기다려야한다면 작업 1 Object 는 Suspend 되지만 작업 1 을 수행하던 Thread 는 그대로 유효하기 때문에 작업 2 도 작업 1 과 동일한 Thread 에서 실행될 수 있습니다.

Coroutine Context란

Kotlin 표준 라이브러리에 정의된 CoroutineContext 타입의 값으로 정의된 어떤 context에서 실행된다.

CoroutineScope

코루틴의 범위, 코루틴 블록을 묶음으로 제어할수 있는 단위

GlobalScope 는 CoroutineScope 의 한 종류입니다. 미리 정의된 방식으로 프로그램 전반에 걸쳐 백그라운드 에서 동작 한다.

Dispachers

코루틴의 실행을 특정 스레드로 제한하거나, 스레드 풀에 보내거나, 제한을 받지 않는 상태로 실행할 수 있다.

Dispatchers.Default : CPU 사용량이 많은 작업에 사용합니다. 주 스레드에서 작업하기에는 너무 긴 작업 들에게 알맞습니다.
Dispatchers.IO : 네트워크, 디스크 사용 할때 사용합니다. 파일 읽고, 쓰고, 소켓을 읽고, 쓰고 작업을 멈추는것에 최적화되어 있습니다.
Dispatchers.Main : 안드로이드의 경우 UI 스레드를 사용합니다.

코루틴 쓰는 방법은?

1. 사용할 Dispatcher 를 결정하고
2. Dispatcher 를 이용해서 CoroutineScope 만들고
3. CoroutineScope 의 launch 또는 async 에 수행할 코드 블록을 넘기면 됩니다.

ex )_다음 예시에서 내부 코루틴 블록은 멈추지 않습니다.

val scope= CoroutineScope(Dispachers.Main)

val job = scope.launch {

//새로운 Scope 생성
CoroutineScope.launch(Dispachers.Main){

// 외부 코루틴이 취소 되어도 끝까지 돌림

  }

}

job.cancel()

외부 코루틴 블록 과 내부 코루틴 블록은 서로 제어범위가 달라진다.

Job 객체의 cancel() 메서드는 자신이 해당하는 CoroutineScope 의 코루틴 블록을 취소시켜 멈출수 있지만, 내부 코루틴 블록은 다른 CoroutineScope 로 분리 되었기 때문에 멈출수 없다.

코루틴 블록이 멈춰도, 내부 코루틴 블록은 끝까지 수행 됨

코루틴 제어를 위한 주요 키워드

-launch, async
-runBlocking
-Job, Deferred

launch는 job 객체를 반환 한다.

val job : Job = launch {
    ...
}

반환받은 Job 객체로 코루틴 블록을 취소하거나, 다음 작업의 수행전 코루틴 블록이 완료 되기를 기다릴 수 있다.

val job:Job = CoroutineScope(Dispachers.IO).launch {
            var i = 0
            while (i < 10) {
                delay(500)
                i++
            }
        }

        job.join() // 완료 대기
        job.cancel() // 취소

여러개의 코루틴 블록을 완료 대기 시킬 수 있다. ( joinAll(job,job) )

val job1: Job = CoroutineScope(Dispatchers.IO).launch {
            var i = 0
            while (i < 10) {
                delay(500)
                println("job1 state = ${this.coroutineContext.job} i=$i")
                i++
            }
        }

val job2: Job = CoroutineScope(Dispatchers.IO).launch {
            var i = 0
            while (i < 10) {
                delay(500)
                println("job2 state = ${this.coroutineContext.job} i=$i")
                i++
            }
        }

        runBlocking {
            joinAll(job1, job2)
            job1.cancel()
            job2.cancel()

            println("${job1.job}")
            println("${job2.job}")

        }

위와 같은 예제로 job1 코루틴 context 객체를 받아서 돌릴 수 있다.

val job1: Job = CoroutineScope(Dispatchers.IO).launch {
            var i = 0
            while (i < 10) {
                delay(500)
                println("job1 state = ${this.coroutineContext.job} i=$i")
                i++
            }
        }

        CoroutineScope().launch(job1) { //
            var i = 0
            while (i < 10) {
                delay(500)
                println("job2 state = ${this.coroutineContext.job} i=$i")
                i++
            }
        }

        runBlocking {
            job1.join()

        }

async() — Deferred

async() 함수로 시작된 코루틴 블록은 Deferred 객체를 반환한다.

val deferred : Deferred<T> = async{
...
    T // 결과값
}

Deferred 객체를 이용해 제어가 가능하며 동시에 코루틴 블록에서 계산된 결과값을 반환 한다.

val deferred: Deferred<Int> = CoroutineScope(Dispatchers.IO).async {
            var i = 0
            var sum = 0;
            while (i < 10) {
                sum += i
                i++
            }

            sum //결과값 반환
        }

        runBlocking {
            val msg = deferred.await() //값을 반환
            println(msg) // result 출력 45
        }
    }

async 코루틴 블록을 실행할 경우 각각의 Deferred 객체에 대해서 await() 함수로 코루틴 블록이 완료 될때까지 다음 코드 수행을 대기 할 수 있습니다. await() 함수는 코루틴 블록이 완료되면 결과를 반환

val deferred1 = CoroutineScope(Dispatchers.IO).async {
            var i = 0
            while (i < 10) {
                delay(500)
                i++
            }

            "result1"
        }

        val deferred2 = CoroutineScope(Dispatchers.IO).async {
            var i = 0
            while (i < 10) {
                delay(1000)
                i++
            }

            "result2"
        }

        runBlocking {
            val result1 = deferred1.await()
            val result2 = deferred2.await()

            println("$result1 , $result2") // result1 , result 2 출력
        }

awaitAll(deferred1,deferred2) //async를 동시에 돌려 결과를 반환 받는다.

코루틴을 블록을 지연 시킬 수 있다.

**CoroutineStart.LAZY**

example :)
- async(context = Dispatchers.IO, start = CoroutineStart.LAZY)
- launch(context = Dispatchers.IO, start = CoroutineStart.LAZY)

start() , (await(), join())의 차이점

start() 함수는 async 코루틴 블록을 실행 시킬땐 블록의 수행 결과를 반환하지 않습니다. 또한 await(),join 함수와 다르게 코루틴 블록이 완료 되는것을 기다리지 않습니다.

start
lazy async 0
lazy async 1
lazy async 2
lazy async 3
lazy async 4
end

start
end
lazy async 0
lazy async 1
lazy async 2
lazy async 3
lazy async 4

runBlocking()

runBlocking() 함수는 코드 블록이 작업을 완료 하기를 기다린다.

runBlocking {
    ...
}

launch() 함수로 시작된 블록은 join() 함수

async() 함수로 시작된 블록은 await() 함수

runBlocking() 함수로 시작된 블록은 아무런 추가 함수 호출 없이 해당 블록이 완료

• 주의점 :

1. runBlocking 코루틴 블록이 사용하는 스레드는 현재 runBlocking() 함수가 호출된 스레드가 된다는 것
2. 안드로이드일 경우 메인스레드에서 호출 하여 시간이 오래 걸리는 작업을 수행하는 경우 ANR 발생 위험

Coroutine 취소

cancel/cancelAndJoin

job을 취소 할 수 있다.

블록내에서 처리 후 cancel()을 호출 할 수 있다.

Cancellation is cooperative

cancel을 할 경우 coroutine의 모든 suspending functions은 취소를 지원 된다.

runBlocking {
            val startTime = System.currentTimeMillis()
            val job = launch(Dispatchers.Default) {
                var nextPrintTime = startTime
                var i = 0
                while (i < 5) {
                    // computation loop, just wastes CPU //
                    yield() //여기에 추가하면 정상적으로 취소된다 
                    // print a message twice a second
                    if (System.currentTimeMillis() >= nextPrintTime) {
                        println("I'm sleeping ${i++} ...")
                        nextPrintTime += 500L
                    }
                }
            }
            delay(1300L) // delay a bit
            println("main: I'm tired of waiting!")
            job.cancelAndJoin() // cancels the job and waits for its completion
            println("main: Now I can quit.")
        }

하지만 위 코드는 블록내의 코루틴이 아닌 코틀린 시스템내에서 작동하는 코드 이므로 while문 안의

취소 여부와 관계 없이 동작 한다.

취소 할 수 있는 방법은 두가지가 있다.

• yeild() - 주기적으로 취소를 체크하는 suspend function을 invoke 시킨다.
• if(isActive) - 명시적으로 조건문을 추가 하여 cancel을 체크 한다.

Androidx는 Android support library를 대체하는 오픈 소스 프로젝트이다.

• Jectpack 내에서 라이브러리를 개발, 테스트, 패키지화, 버전 및 릴리즈하기 위해 사용한다.
• Support Library와 마찬가지로 AndroidX는 Android OS와 별도 구분되며, Android Release전반에 걸쳐 이전 버전과의 호환성을 제공한다.
• AndroidX 기능 패키지 및 새 라이브러리를 제공하여 Android Support Library를 완전히 대체 한다.
• AndroidX의 모든 패키지는 androidx 문자열로 시작하는 일관된 네임 스페이스가 있으며, androidx.* 패키지로 매핑 되어 있다.
• Support Library와 다르게 별도로 유지 관리 되고 업데이트 된다.

AndroidX 사용

• Android Studio 3.2 버전 이상, 빌드 28.0 이상 버전부터 사용 가능
• gradle.properties파일에서 android.userAndroidX:true 설정
• 기존 Support Library를 사용하던 프로젝트에서 Android Studio를 통해서 AndroidX migration 기능을 제공하기 때문에 백업 후 마이그레이션이 가능하다.

자바의 클래스와 메소드드는 기본적으로 상속에 대해 열려 있지만 코틀린의 클래스와 메소드는 기본적으로 final이다. 어떤 클래스의 상속을 허용하려면 클래스 앞에 open 변경자를 붙여야 한다. 더불어 오버라이드를 허용하고 싶은 메소드나 프로퍼티의 앞에도 open 변경자를 붙여야 한다.

클래스 내에 오버라이드를 강제 금지 시키려면 final 변경자를 붙이면 된다. 그럼 상속 받은 클래스는 해당 메소드를 오버라이드 할 수 없다.

interface ClickAble{
    fun showOff()= println("i'm click able!")
    fun click()
    fun showOn()
}


open class BaseButton :ClickAble{ //이 클래스는 열려 있는 클래스다. 다른 클래스가 이 클래스를 상속 할 수 있다.

    fun disable(){} //이 함수는 파이널이다. 하위 클래스가 이 메소드를 오버라이드 할 수 없다.

    open fun animate(){} // 이 함수는 열려 있다. 하위 클래스에서 이 메소드를 오버라이드 해도 된다. 

    override fun click(){} // 이 함수는 열려있는 메소드를 오버라이드 한다.

    final override fun showOn() {} // final 변경자를 이용해 오버라이드를 금지 시킨다.

}

class RichButton:BaseButton(){   //BaseButton 상속

    override fun animate() {  //open animate 함수 오버라이드
        super.animate()
    }
      override fun showOff() { //ClickAble interface 메소드 상속
        super.showOff()
    }
}

• abstract 추상 클래스 정의하기

일반 자바와 마찬가지로 abstract는 하위 클래스에서 오버라이드 해야 한다.

abstract class Animated{   //이 클래스는 추상 클래스이다.
    abstract fun animate()  // 이 함수는 추상 함수이다. 이 함수에는 구현이 없다. 하위 클래스에서는 이 함수를 무조건 오버라이드 해야한다.

    open fun stopAnimating(){}
    fun animateTwice(){}
    //추상클래스내에 속하지만 비추상 함수이므로 무조건 오버라이드 할 필요 없다.
}

final(기본 변경자) : 오버라이드 할수 없음 / 클래스 멤버의 기본 변경자 open : 오버리이드 할수 있음 / 반드시 oepn을 명시해야 오버라이드 할 수 있다 abstract : 무조건 오버라이드 해야 함/ 추상 클래스의 멤버에만 이 변경자를 붙일 수 있다. 추상 멤버에는 구현이 있으면 안된다. override : 상위 클래스나 상위 인스턴스의 멤버를 오버라이드 하는중 / 오버라이드 하는 멤버는 기본적으로 열려있다. 하위 클래스의 오버라이드를 금지하려면 final을 명시해줘야한다.

가시성 변경자

가시성 변경자는 코드 기반에 있는 선언에 대한 클래스 외부 접근을 제어한다. 코틀린에서는 같은 패키지 내 모듈안에서만 볼 수 있는 internal 가시성을 추가했다.

public(기본 가시성) : 모든곳에서 볼 수 있다. internal : 같은 모듈 안에서만 볼 수 있다. protected : 하위 클래스 안에서만 볼 수 있다. 최상위 선언에는 사용 할 수 없다. private : 같은 클래스 안에서만 볼 수 있다.

internal open class TalkativeButton :Focusable{
    private fun yell() = println("Yell")
    protected fun whisper() = println("Let's talk!")
}

fun TalkativeButton.giveSpeech(){    //public 멤버가 자신의 intenal 수신 타입인 TalkativeButton 노출함
    yell() //private 가시성인 yell 접근 할수 없음
    whisper() //protected whisper을 접근 할수 없음
}

internal
클래스를 확장한 함수는 private , protected 함수를 불러 올 수 없다.

코틀린 인터페이스는 자바 8 인터페이스와 비슷하다. 안에는 추상 메소드뿐 아니라 구현이 있는 메소드도 정의 할 수 있다.

interface clickable {
  fun click()
}

위 코드는 추상 메소드가 있는 인터페이스를 정의 한다. 이 인터페이스를 구현하는 모든 비추상 클래스에 대한 구현을 제공 해야한다.

class Button0:ClickAble{
    override fun click() = println("I was clicked")
}
val btn = Button0()
btn.click()
>>>I was clicked

자바에서는 extends와 implements 키워드를 이용하지만 코틀린에서는 클래스 이름 뒤에 콜론(:)뒤에 상속 받을 클래스 또는 인터페이스를 정의한다. 자바의 @Override 애노테이션과 비슷한 override 변경자는 상위 클래스나 상위 인터페이스에 있는 프로퍼티나 메소드를 오버라이드 한다는 뜻이다.

---디폴트가 있는 메소드 정의

interface ClickAble{
    fun click()
    fun showOff()= println("i'm click able")
}

/** class Button0: **/
val btn = Button0()
btn.showOff()
>>>i'm click able

인터페이스 내에 디폴트가 있는 메소드는 클래스 내에서 오버라이드 할 필요 없이 바로 사용이 가능하다.

만약 2개를 상속한 인터페이스에 같은 이름의 함수값이 있으면 어떻게 처리해야할까??

interface ClickAble{
    fun showOff()= println("i'm click able")
}

interface Focusable{
    fun showOff()=pruntln("i'm focusable")
}

class Button0:ClickAble,Focusable{
    override fun showOff() {
        super<ClickAble>.showOff()
        super<Focusable>.showOff()
    }
}

val btn = Button0()
btn.showOff()

>>>i'm click able!
i'm focusable!

위 처럼 꺽쇠 기호 안에 인터페이스의 타입을 입력해서 부를 수 가 있다. 하지만 단 하나만 호출하게 된다면 어떻게 해야할지 알아보자

class Button0:ClickAble,Focusable{
    override fun showOff() = super<ClickAble>.showOff()
}

val btn = Button0()
btn.showOff()

>>>i'm click able!

자바에서 코틀린의 메소드가 있는 인터페이스 구현하기 자바의 인터페이스는 디폴트 메소드를 지원하지 않는다. 따라서 디폴트 메소드가 정적 메소드로 들어있는 클래스를 조합해 구현한다. 따라서 자바에서는 코틀린의 디폴트 메소드 구현에 의존 할 수 없다.

--- 유저 필드 검증을 체크하는 로직

class User(val id:Int, val name:String,val address :String)

fun saveUser(user:User){
    if (user.name.isEmpty()){
        throw IllegalArgumentException(
            "Can't save user ${user.id} : empty Name"
        )
    }
    if (user.address.isEmpty()){
        throw IllegalArgumentException(
            "Can't save user ${user.address} : empty Address"
        )
    }
}

saveUser(User(1,"",""))

>>java.lang.IllegalArgumentException: Can't save user 1 : empty Name

여기서는 코드중복이 그렇게 많지 않지만 추 후에 검증에 관련된 value 값들을 하나하나 넣으면 코드가 길어지게 된다. 다음은 로컬 함수를 이용해 유저 필드를 체크하는 로직을 만들어보자

--- 함수안에 로컬함수를 이용하여 유저필드를 체크하는 로직
class User(val id:Int, val name:String,val address :String)

fun saveUser(user: User) {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException(
                "Can't save user ${user.id} : $fieldName"
            )
        }
    }
    validate(user.name,"Name")
    validate(user.address,"Address")

}

saveUser(User(1,"zzz",""))
>>java.lang.IllegalArgumentException: Can't save user 1 : empty Address

위와 같이 함수안에 함수를 구현하여 체크를 하는 요소를 줄어들었다. 여기서 좀 더 검증로직을 하는 함수를 만들고 싶으면 확장 함수를 쓰면 된다.

--- 확장 함수를 이용한 유저필드를 체크하는 로직

fun User.validateBeforeSave(){
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException(
                "Can't save user $id : $fieldName"
            )
        }
    }
    validate(name,"Name")
    validate(address,"Address")
}

fun saveUser(user: User) {
    user.validateBeforeSave()
}

saveUser(User(1,"zzz",""))
>>java.lang.IllegalArgumentException: Can't save user 1 : empty Address

확장함수를 이용하면 위와 같이 id와 name, address를 객체 멤버 처럼 수신객체(this)를 지정하지 않아도 바로 쓸수가 있다. 함수안에 중첩으로 함수를 넣는게 가능하지만 나중에 코드가 읽기 어려워져 한단계만 중첩 시키는걸 권장한다.

• vararg 키워드를 사용하면 호출 시 인자 개수가 달라질 수 있는 함수를 정의할 수 있다.
• 중위(infix)함수 호출 구문을 사용하면 인자가 하나뿐인 메소드를 간편하게 호출 할 수 있다.
• 구조 분해 선언을 사용하면 복합적인 값을 분해해서 여러 변수에 나눠 담을 수 있다.

자바 컬렌션 API 확장

val strings : List<String> = listOf("first","second","fourtheeth")
strings.last
>>fourtheeth

val numbers:Collection<Int> = setOf(1,14,2)
number.max
>>14

위의 코드와 같이 last, max는 확장 함수이다.

fun <T>List<T>.last():T { /* 마지막 원소를 반환함 */ }
fun Collection<Int>.max() :Int { /* 컬렉션의 최댓값을 찾음 */ }

코틀린 표준 라이브러리는 수많은 확장 함수를 포함한다

가변 인자 함수

리스트를 생성하는 함수를 호출 할 때 원하는 만큼 많이 원소를 전달 할 수 있다.

val list = listOf(2,3,5,7,11)

라이브러리에서의 함수 정의

fun listOf<T>(vararg values:T):List<T>{ ... }

1. 자바의 가변길이는 타입뒤에 ...를 붙이지만 코틀린은 vararg 변경자를 붙인다.
2. 가변 길이 인자는 메소드를 호출 할 때 원하는 개수만큼 값을 인자로 넘기면 자바 컴파일러가 배열에 그 값들을 넣어준다.
3. 자바에서는 배열을 그냥 넘기면 되지만 코틀린에서는 배열을 명시적으로 풀어서 각 원소가 인자로 전달되게 해야한다. 이걸 기술적으로 스프레드 연산자가 그런 작업을 한다. 실제로 전달하려는 배열 앞에 *를 붙이기만 하면 된다.

--스프레드 연산자
val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)
println(list)
>>[-1, 0, 1, 2, 3, 4]

중위 호출과 구조 분해 선언

간단하게 mapOf 함수를 이용해보자

val map = mapOf(1 to "one", 7 to "seven", 53 to "fifity-three")

여기서 to 키워드는 본래 코틀린에 있던 키워드가 아니다. 이 코드는 중위호출(infix call)이라는 특별한 방식으로 to라는 일반 메소드를 호출 한 것이다. 중위 호출 시에는 수신 객체와 유일한 메소드 인자 사이에 메소드 이름을 넣는다.

infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

이 to 함수는 Pair 인스턴스를 반환한다. Pair는 코틀린 표준 라이브러리 클래스로 두 원소 이뤄진 순서쌍을 표현한다. Pair의 내용으로 두 변수를 즉시 초기화 할 수 있다.

val (number,name) = 1 to "one"

이런 기능을 구조 분해 선언이라 부른다

• 중위호출(infix), 구조 분해(Destructuring) 선의 또 다른 예

---중위호출 다른 예

infix fun Int.multiply(x: Int): Int { //infix로선언되므로중위함수
return this * x
}

println(10 multiply 3)
>> 30

--- 구조 분해 선언 다른 예

 class Car(private val manufacturer:Any, private val model:Any){
   operator fun component1() = manufacturer
   operator fun component2() = model
 }

 val car = Car("현대", "그랜저")
 val (manufacturer, model) = car
 println("제조사 : $manufacturer, 모델 : $model")

어떤 클래스의 멤버 메소드인 것 처럼 호출 할 수 있지만 클래스 밖에 선언된 함수이다.

문자열의 마지막값을 돌려주는 함수

package strings
fun String.lastChar() : Char = this.get(this.length -1)

확장 함수를 만들려면 추가하는 함수 이름 앞에 그 함수가 확장할 클래스의 이름을 붙이면 된다. 클래스 이름을 수신객체 타입 이라 부르며 확장함수가 호출되는 대상을 수신 객체 라고 부른다.

fun String(수신객체 타입).lastChar: Char = this(수신객체).get(this(수신객체).length - 1)


println("Kotlin".lastChar()) //호출
>>n

수신 객체 멤버에 this 없이도 사용이 가능하다.

fun String.lastChar: Char = get(length - 1) //this 생략

1. 일반적인 인스턴스 메소드의 내부에서와 마찬가지로 수신 객체의 메소드나 프로퍼티를 바로 사용 할 수 있다.
2. 클래스 내부에서만 사용 할 수 있는 private 멤버나 protected 멤버를 사용 할 수 없다

임포트와 확장 함수

외부 클래스에서 확장 함수 정의를 임포트를 통해 사용이 가능하다. 한 클래스 내에서 함수의 같은 이름이 충돌 하는 경우가 자주 생길 수 있는데, 임포트를 통해 개별 함수를 정할 수가 있다.

import string.lastChar

val c = "Kotlin".lastChar()

-- *를 사용한 임포트도 잘 작동한다.

import strings.*   

val c = "Kotlin".lastChar()

--- as키워드를 통한 임포트한 클래스나 함수를 다른 이름으로 부를 수 있다.

import string.lastChar as last

val c = "Kotlin".last()

• 자바에서의 호출

  확장 함수는 수신객체를 첫 번째 인자로 받는 정적 메소드 이다. 때문에 코틀린의 파일명에 따라 자바의 클래스 이름이 선언되기 때문에 StringUtil.kt 파일에 정의 했다면 다음과 같이 호출 할 수 있다.

char c = StringUtilKt.lastChar("JAVA");

확장함수는 오버라이드 될 수 없다.

코틀린의 오버라이드도 객체지향의 오버라이드와 마찬가지로 코딩을 하면 된다.

---- 일반적인 멤버함수 오버라이드

open class View{

open fun click() = println("View clicked")
}

class Button:View(){

   override fun click() = println("Button clicked")
}

val view:View = Button()
view.clicked()
>>Button clicked

• 여기서 확장 함수로 showOff라는 메소드를 만들어 테스트를 해보자

fun View.showOff() = println("Im a View!")
fun Button.showOff() = println("Im a Button!")

val view:View = Button()
view.showOff()
>>Im a View!

위 코드에서는 view 변수가 Button 실제 객체 타입을 들고 있지만 이 경우 타입이 View이기 때문에 View의 확장 함수가 호출된다. 이유는 확장함수는 static한 정적 메소드로서 컴파일 시점때 미리 View 타입으로 결정하기 때문이다.

확장프로퍼티

---확장 프로퍼티 선언 
val String.lastChar:Char
   get() = get(length -1 )

확장 함수의 경우와 마찬가지로 확장 프로퍼티도 일반적인 프로퍼티와 같은데, 뒷받침하는 필드가 없어서 기본 게터 구현을 제공 할 수 없으므로 최소한 게터는 꼭 정의를 해야한다.

---변경 가능한 확장 프로퍼티 선언

var StringBuilder.lastChar:Char
    get() = get (length -1 )
    set(value:Char){
    this.setCharAt(length -1 , value)
    }


println("Kotlin".lastChar)
>> n

val sb = StringBuilder("Kotlin?")
sb.lastChar = '!'
println(sb)
>> Kotlin!

확장 프로퍼티를 사용하는 방법은 멤버 프로퍼티를 사용하는 방법과 같다. 자바에서는 StringUtilKt(코틀린파일네임명).getLastChar("JAVA") 처럼 게터나 세터를 명시적으로 호출 해야한다.

• 기존 자바에서는 하나의 메소드 또는 프로퍼티를 호출하기 위해서는 클래스안에 포함시켜아한다. 하지만 코틀린에서는 메소드 또는 프로퍼티를 파일안에 클래스 없이 최상위 수준에 위치 하면 된다.

---아래 코드 처럼 클래스 없이 파일안에 최상위 함수로 선언 할 수 있다.
package strings
JoinStr.kt


fun joinToString():String{...}

JVM이 클래스 안에 들어있는 코드만을 실행 할 수 있기 때문에 컴파일러는 파일을 컴파일 할 때 클래스를 정의 해준다.

• 위 코드를 자바코드로 컴파일 했을 때

  package strings;
  

public class JoinKt{ public static String joinToString(...){ ... } }

>클래스 이름은 코틀린 소스 파일의 이름과 대응한다. 코틀린의 모든 최상위 함수는 클래스의 정적인 메소드가 된다.

- 자바에서 코틀린 정적 함수 호출

import strings.JoinKt;

JoinKt.joinToString(list,",","","")

> - 파일에 대응하는 클래스의 이름 변경
 코틀린 최상위 함수가 포함되는 클래스의 이름을 바꾸고 싶다면 **@JvmName 어노테이션을 추가** 한다.
 어노테이션의 위치는 파일의 맨 앞. 패키지 이름 선언 이전에 위치한다.

 ### 최상위 프로퍼티
 최상위 함수와 마찬가지로 프로퍼티도 파일의 최상위 수준에 놓을 수 있다.

var opCount = 0 fun performOperation(){ opCount++ // ... } fun reportOperationCount(){ println("Operation performed $opCount times") }

>프로퍼티의 값은 정적 필드에 저장된다.

- 최상위 프로퍼티를 활용해 코드에 상수를 추가 할 수 있다. 

val UIX_LINE_SEPARATOR ="\n"

 기본적으로 최상위 프로퍼티도 다른 모든 프로퍼티 처럼 접근자 메소드를 통해 자바에 노출 된다.
 위와 같은 상수를 자연스럽게 이용하려면 const 변경자를 추가하면 된다.
**단 원시 타입과 String타입의 프로퍼티만 const로 지정 가능 **

--kotlin--- const val UIX_LINE_SEPARATOR ="\n"

--java--- public static final String UIX_LINE_SEPARATOR ="\n"

• 코틀린에서는 자바와 같이 여러가지 컬렉션을 만들 수 있다.

  val set = hashSetOf(1,7,53) //set 컬렉션
  val list = arrayList(1,7,53) //arrayList 컬렉션
  val map = hashMapOf(1 to "one",7 to "seven", 53 to "fifty-three") //map 컬렉션

  코틀린의 collection 함수는 자바의 상호작용을 위해 자바의 컬렉션을 통해 제공된다. 코틀린 자체에서 컬렉션을 제공하지 않는다.

• 코틀린은 자바보다 컬렉션에 제공되는 함수가 많다.

  val strings = listOf("first","second","fourteeth")
  println(strings.last())
  >>fourteeth
  val numbers = setOf(1,14,2)
  println(numbers.max())
  >>14

  추후에 자바에 없는 메소드를 코틀린에서는 어떻게 동작하는지 알아보자.

함수를 호출하기 쉽게 만들기

• 간단히 list를 출력하는 함수를 만들어보자

val list = listOf(1,2,3)
println(list)     //toString()
>> [1,2,3]

여기서 내가 원하는 출력값은 단순히 1,2,3이 나오길 원하는데 출력은 [1,2,3]이 나온다. 그럼 우리가 원하는 list의 형태가 나오게 구현하는 예시를 짜보자

-- 원하는 출력 형태 : (1,2,3)

fun <T> joinToString(
    collection:Collection<T>,
    separator:String,
    prefix:String,
    postfix :String
):String{
    val result = StringBuilder(prefix)
    for((index,element) in collection.withIndex()){
        if (index >0) result.append(separator)
        result.append(element)
    }
    result.append(postfix)
    return result.toString()

    val list = listOf(1,2,3)
    println(joinToString(list,",","(",")"))

    >>(1,2,3)
}

결과값이 잘 나온다. 하지만 가독성에 있어서 아쉬운 부분이 많다. 좀 더 깔끔하게 표현을 해보자.

• ** 코틀린에서는 인자를 딴 이름을 명시 할 수 있다.**

println(joinToString(collection = list ,
separator =","  ,
prefix = "(" ,
postfix = ")" )
)

다음과 같이 이름을 명시하면 좀 더 가독성이 좋아보인다. 하지만 이름을 명시하면 모든 인자 값에 이름을 명시 해야하는 문제점이 있다. default parameter(디폴트 파라미터) 통해 좀 더 가독성이 좋게 보일 수 있다. warning : 자바로 작성한 코드를 호출 할때는 이름 붙인 인자를 사용할 수가 없다

• 디폴트 파라미터 값

자바의 일부 클래스에서 오버로딩한 메소드가 너무 많아진다는 문제가 있다. 오버로딩 메소드들은 하위 호환성을 유지하거나 API 사용자에게 편의를 더하는 등의 여러가지 이유로 만들어 진다. 어느 경우든 중복이 되는 경우가 많은데 코틀린에서는 함수 선언에 파라미터의 디폴트 값을 지정할 수 있어 이러한 문제점을 피해 갈 수 있다.

fun <T> joinToString(
    collection:Collection<T>,
    separator:String=",", //디폴트 값 ","이 지정되었다.
    prefix:String="", //디폴트 값 ""이 지정되었다.
    postfix :String="" //디폴트 값 ""이 지정되었다.
):String{
    // *** //
}

println(joinToString(list)) // separator,prefix,postfix 생략
>> 1,2,3
println(joinToString(list,postfix=";",prefix="#")) prefix,postfix 지정
>> #1,2,3;

위와 같이 디폴트 값을 정해놓으면 필요한 인자만 값을 넣으면 되는 장점이 있다.

• 함수를 정의 할 때 fun 키워드를 이용한다.
• val : 읽기전용 변수, var : 변경 가능한 변수에 쓰인다.
• 문자열 템플릿은 변수이름 앞에 $ 붙이거나, 식을 ${식}처럼 블록으로 둘러싸면 변수나 식의 값을 문자열에 넣을 수 있다.
• if는 코틀린에서 식이며, 값을 만들어 낸다.
• 코를린에서는 when은 자바의 switch케이스와 비슷한데 식으로도 이용이 가능하다.
• 변수의 타입을 검사하고 나면 변수를 캐스팅 하지 않아도 검사한 타입의 변수처럼 사용 할 수 있다. 이 같은 경우 컴파일러가 자동으로 스마트캐스팅을 해준다.
• for,while,do-while 루프는 자바가 제공하는 키워드와 비슷하다.
• 1..5 같은 식은 범위를 만들어낸다. 범위와 수열은 코틀린에서 같은 문법을 사용하며, for 루프에 대한 같은 추상화를 제공한다. 어떤 값이 범위 안에 들어 있거나 들어있지 않은지 검사하기 위해 in 이나 !in 을 이용한다.
• 코틀린에서 예외처리는 자바와 비슷하다. 다만 코틀린에서는 함수가 던질 수 있는 예외를 선언하지 않아도 된다.

• 코틀린의 예외처리는 자바의 예외처리와 전혀 다르지 않다.
• throw를 식으로 처리가 가능하다.

  if (percentage !in 0..100){
   throw IllegalArgmentException(
       "A percentage value must be between 0 and 100: $percentage") 
  }
  

val pecentage = if(num in 0..100) number else throw IllegalArgmentException( "A percentage value must be between 0 and 100: $percentage")

### try,catch,finally

자바와 마찬가지로 예외처리를 하려면 try,catch,finally 절을 함께 사용한다.

-이 코드는 파일에서 각 줄을 읽어 수로 변환하되 그 줄이 올바른 형태가 아니면 null 을 반환하는 예제이다.

fun readNumber(reader:BufferedReader):Int?{ try { val line = reader.readLine() return Integer.parseInt(line) }catch (e:NumberFormatException){ return null }finally { reader.close() } }

val reader = BufferedReader(StringReader("239")) println(readNumber(reader))

239

- 코틀린에서는 try catch문을 이용해 식으로도 만들 수 있다.
~~~
     fun readNumber(reader:BufferedReader){
        val num = try {
            Integer.parseInt(reader.readLine())
        } catch (e: NumberFormatException) {
            null
        }
        println(num)
    }

  val reader = BufferedReader(StringReader("not a number"))
  println(readNumber(reader))

 >>>null

~~~
>위 코드는 예외가 만족하면 문자열 숫자를 반환하고 아닐 경우 예외처리가 될 경우 null을 반환한다.
1. 식 안에서는 마지막 문장이 리턴값이 된다.

코틀린에서 while과 do-while 루프가 있다. 두 루프의 문법은 자바와 다르지 않다.

while(조건){  //조건이 참이 될때까지 본문을 반복 실행한다.
  /*...*/
}

do{   //맨 처음에 본문을 한 번 실행한 다음. 조건이 참인 동안 본문을 반복 실행

}while(조건)

수에 대한 이터레이션: 범위와 수열

코틀린에는 자바의 for 루프(변수를 초기화 하고 루프를 실행 할때마다 갱신하고 루프 조건이 거짓이 될때 반복을 마치는 형태의 루프)에 해당하는 요소가 없다. 루프를 대신하기 위해 코틀린에서는 범위(range)를 사용한다.

val oneToTen= 1..10

when을 사용해 피즈버즈 게임 구현(주석 코드 설명)


fun fizzBuzz(i: Int) = when { //return값 문자열로 반환 생략
        i % 15 == 0 -> "FizzBuzz" //정수값 i 가 15로 나눠지면 FizzBuzz로 반환
        i % 3 == 0 -> "Fizz" // 정수값 i 가 3로 나눠지면 Fizz로 반환
        i % 5 == 0 -> "Buzz" 정수값 i 가 5로 나눠지면 Buzz로 반환
        else -> "$i" //그 외는 자신의 숫자로 반환
}

for (i in 1..100){   //1..100까지의 정수에 대해 이터레이션 한다.
     println(fizzBuzz(i))
}

>>> 1 2 Fizz 4 Buzz Fizz 7 ...

증가 값을 갖고 범위 이터레이션 하기(주석 코드 설명)
   for (i in 100 downTo 1 step 2){ //downTo : 100에서 1까지 역방향으로 내려온다. 
                                     step : 2 정수값을 건너뛴다.
     println(fizzBuzz(i))
 }

 >>> Buzz 98 Fizz 94 92 FizzBuzz 88 ...

• 맵에 대한 이터레이션

        val binaryReps = TreeMap<Char,String>() //키에 대해 정렬하기 위해 TreeMap 이용

        for (c in 'A'..'F'){ //A 부터 F까지 문자의 범위를 사용해 이터레이션 한다.
            val binary = Integer.toBinaryString(c.code) //아스키 코드를 2진 표현으로 변경
            binaryReps[c] = binary //c를 키로 c의 2진 표현을 맵에 넣는다.
            (자바에서는 binaryReps.put(c,bianry)로 코딩
        }

        for ((letter,binary) in binaryReps){ //맵에 대해 이터레이션 한다. 맵의 키와 값을 두변수에 각각 대입한다.
            println("$letter = $binary")
        }

 >>>
A = 1000001
B = 1000010
C = 1000011
D = 1000100
E = 1000101
F = 1000110

이터레이션에는 숫자 값이 아닌 문자 타입의 값에도 적용 할 수 있다.

in으로 컬렉션이나 범위의 원소 검사

fun isLetter(c:Char) = c in 'a'..'z' || c in 'A'..'Z' // 'a' <= c && c <= 'z'로 변환
fun isNotDigit(c:Char) = c !in '0'..'9'
println(isLetter('A'))
println(isNotDigit('0'))


true
false

1. in 연산자를 사용해 어떤 값이 범위에 속하느지 검사 할 수 있다.
2. !in 연산자를 통해 어떤 값이 범위에 속하지 않는지 검사 할 수 있다.

다른 예제

-when 에서 in 사용하기
fun reconzine(c:Char) = when(c){
  in '0'..'9' -> "It's a digit"
  in 'a'..'z', in 'A'..'Z' -> "It's a letter"
  else -> "i don`t know.."
 }

  println(reconzine('A'))

  >>>It's a letter


 -setOf를 이용한 in 사용하기

  println("Kotlin" in setOf("JAVA","Scala"))
  >>>false

간단하게 무지개색을 표현하는 enum class를 만들어보자

enum class Color{
  RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET
}

1. 자바에서는 enum 이지만 코틀린에서는 enum class 이다.
2. 코틀린에서 enum은 소프트 키워드라 부르는 존재다
3. 코틀린은 자바와 다르게 enum에 단순히 값만 열거하는 존재가 아니고 class 이기 때문에 프로퍼티나 메소드를 정의할 수 있다.

--- enum class 프로퍼티, 메소드 예제

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),
    BLUE(0,0,255),
    INDIGO(75,0,130),
    VIOLET(238,130,238);

    fun rgb() = (r * 256+ g) * 256 + b
}

println(Color.BLUE.rgb())
>>>255

enum class에 메소드를 정의 하는 경우 enum 상수목록과 메소드 사이에 세미콜론이 존재 하여야 한다.

when

• 자바에서 switch case 문을 이용하지만 kotlin에서는 when절을 이용해 분기 처리가 가능하다.
• if문과 마찬가지로 when절도 식으로 만들어 낼 수 있다

fun getMnemonic(color:Color)=
when(color){
 Color.RED ->"Richard"
 Color.ORANGE ->"Of"
 Color.YELLOW ->"York"
 Color.GREEN -> "Gave"
 Color.BLUE -> "Battle"
 Color.INDIGO -> "In"
 Color.VIOLET -> "Vain
}

println(getMenemonic(Color.BLUE))
>>Battle

위 코드는 color로 전달된 값과 같은 분기를 찾는 코드이다.

1. when 은 자바와 달리 마지막 구문에 break를 넣지 않아도 된다.

----여러값을 매치 패턴으로 할 경우

fun getMnemonic(color:Color)=
when(color){
 Color.RED,Color.ORANGE,Color.YELLOW  ->"warm" // 여러값을 구분 할때 콤마(,)로 표시
 Color.GREEN -> "neutral"
 Color.BLUE,Color.INDIGO,Color.VIOLET -> "cold"
}

println(getMenemonic(Color.BLUE))
>>cold

한 분기 안에서 여러값을 매치 패턴으로 사용 할 수 있으며 콤마(,)로 분리한다.

• when은 임의의 객체를 함께 사용 가능하다.

----setOf를 통한 임의의 객체

fun mix(c1:Color,c2:Color) = 
when(setOf(c1,c2)){
 setOf(RED,ORANGE)  ->ORANGE  
 setOf(YELLO,BLUE) -> GREEN
 setOf(BLUE,VIOLET) -> IDIGO
 else -> throw Exception("Dirty color")
}


println(mix(Color.RED,Color.ORANGE))
>> ORANGE

위 코드에서는 c1,c2 인자값을 받아 setOf(객체)를 통해 분기 처리를 하였다. 만약 위의 조건을 성립하지 않으면 else를 타서 exception을 타게 된다.

인자 없는 when 사용

• when절은 인자 없이도 사용이 가능하다.

  fun mix(c1:Color,c2:Color) = 
  when{
  (c1 == RED && c2 == YELLOW) ||
  (c1 == YELLOW && c2 == RED) -> ORANGE
  (c1 == YELLOW && c2 == BLUE) ||
  (c1 == BLUE && c2 == YELLOW) -> GREEN
  (c1 == BLUE && c2 == VIOLET) ||
  (c1 == VIOLET && c2 == BLUE) -> INDIGO
  else -> throw Exception("Dirty color")
  }
  
  

println(mix(Color.BLUE,Color.YELLOW))

GREEN

> 1. when에 아무 인자가 없으면 분기의 조건이 bool 결과를 계산하는 식이어야 한다.
2. 추가객체를 만들지 않는다는 장점은 있지만 가독성이 떨어진다.

### 스마트 캐스트 : 타입 검사와 타입 캐스트를 조합

- 간단한 산술식을 계산하는 함수를 만들어보자

interface Expr { class Num(val value: Int) : Expr // value 라는 프로퍼티만 존재하는 Num class class Sum(val left: Expr, val right: Expr) : Expr // Exper 타입의 객체라면 어떤 것이나 연산의 인자가 될 수 있다. }

fun eval(e: Expr): Int { if (e is Expr.Num) { return e.value } if (e is Expr.Sum) { return eval(e.right) + eval(e.left) } throw IllegalArgumentException("Unknown expressions") }

println(eval(Expr.Sum(Expr.Sum(Expr.Num(1),Expr.Num(2)),Expr.Num(4))))

7

> **스마트 캐스트**
코틀린에서는 is를 사용해 변수타입을 검사한다. (자바에서는 instanceof)
자바에서는 instanceof로 확인한 타입에 속한 멤버를 접근하기 위해서는 명시적으로 변수 타입을 캐스팅 해야한다.
하지만 코틀린에서는 **어떤 타입인지 is로 검사하고 나면 굳이 변수를 원하는 캐스팅하지 않아도 변수가 원하는 타입으로 선언된것 처럼 사용 할 수 있는 장점이 있고 이를 프로그래머 대신 컴파일러가 캐스팅**을 해준다.

### 리팩토링 : if를 when으로 변경

fun eval(e: Expr): Int = when(e){ is Expr.Num-> e.value is Expr.Sum -> eval(e.right) + eval(e.left) else -> throw IllegalArgumentException("Unknown expressions") }

> when으로 분기마다 변수타입을 검사 한 후 반환값을 자동으로 스마트 캐스팅 해 줄 수 있다
가독성이 더 좋아보이는 장점이 있다.

### if와 when을 분기에서 블록 사용

fun evalWithLogging(e: Expr): Int = when (e) { is Expr.Num -> { println("num: ${e.value}") // 마지막 e.value 가 반환된다. e.value } is Expr.Sum -> { val left = evalWithLogging(e.left) val right = evalWithLogging(e.right) println("sum : $left + $right") left + right //e의 타입이 sum이면 이 식이 반환된다. } else -> throw IllegalArgumentException("Unknown expressions") }

println(evalWithLogging(Expr.Sum(Expr.Sum(Expr.Num(1), Expr.Num(2)), Expr.Num(4))))

num: 1 num: 2 sum : 1+2 num: 4 sum : 3+4 7

~

when절을 식으로 이용 할 땐 블록의 마지막 결과값을 반환한다.

--- 자바 클래스
public class Person{

private final String name;

public Person(String name){
 this.name = name;
 }

public String getName(){
  return name;
}
 }


--- 코틀린 클래스
class Person(val name:String)

자바는 필드가 둘 이상으로 늘어나면 생성자인 본문에서 파라미터를 대입하는 대입문의 수도 늘어난다. 코틀린에서는 필드 대입 로직을 훨씬 더 적은 코드로 작성 할 수 있다. 이러한 유형의 클래스를 값 객체라 부르며 간결하게 기술 할 수 있는 구문을 제공한다.

프로퍼티

클래스는 자신을 이용하는 클라이언트가 데이터에 접근하는 통로로 접근자 메소드를 제공한다. 필드를 읽기 위한 게터 제공하고 필드를 변경하게 허용해야 할 경우 세터를 추가 제공 할 수 있다. 필드와 접근자를 한데 묶어 프로퍼티라고 부른다.

코틀린 클래스 안에서 프로퍼티

class Person(
val name:String, //읽기전용 프로퍼티, 비공개 필드와 필드를 읽는 공개 게터로 만들어낸다.
val isMarried:Boolean // 변경가능한 프로퍼티, 비공개 필드, 공개 세터, 공개 게터로 만들어낸다.
)

• Person안에는 비공개 필드가 들어가 있고 생성자가 그 필드를 초기화 하며 게터를 통해 비공개 필드에 접근하며 자바와 코틀린이 동일하게 사용된다.

• 자바에서 Person 클래스 사용방법

  Person person =new Person("bob",true)
  System.out.println(person.getName())
  >>bob
  System.out.println(person.isMarried())
  >>true

• 코틀린에서 Person 클래스 사용방법

  val person = Person("bob",true) // new 키워드를 사용하지 않고 생성자를 호출한다.
  println(person.name) //프로퍼티 이름을 직접 사용해도 코틀린이 자동으로 게터를 호출해준다.
  >>bob
  println(person.isMarried)
  >>true

커스텀 접근자

프로퍼티의 접근자를 직접 작성 할 수 있다.

 다음 예시는 사각형 클래스를 정의 하면서 자신이 정사각형인지 확인 여부를 알 수 있는 코드이다.

 class Rectangle(val height:Int,val width:Int){
    val isSquare:Boolean
    get() {   //프로퍼티 게터 선언
       return height == width
    }
    //또는 get() = height== width로 구현이 가능
}

1. isSqaure 프로퍼티에는 자체 값을 저장하는 필드가 필요 없다.
2. 이 프로퍼티에는 구현을 제공 하는 게터만 존재한다.
3. 클라이언트가 isSquare 프로퍼티에 접근 할 때 마다 프로퍼티 값을 매번 계산한다.

fun main(args: Array<String>){
   println("Hello World")
}

• 함수선언을 할때 fun 키워드 이용한다.
• 파리미터 : 파라미터 이름 뒤에 타입을 쓴다. (args : Array<String>)
• 자바와 달리 함수를 최상위 수준에 정의 할 수 있다. class안에 함수를 넣어야 할 필요가 없다.
• 배열도 일반적인 클래스와 마찬가지다.
• 코드 끝에 세미콜론(;)을 넣을 필요가 없다.

기본 함수

fun max(a:Int,b:Int):Int{
   return if(a>b) a else b
}

• 함수는 fun 키워드 그 뒤에 함수 이름이 온다 그리고 괄호를 열어 파라미터 목록이 온다. 그리고 그 뒤에는 :Type 을 넣어 반환할 타입을 정한다. fun max(a:Int,b:Int):Int
• 함수 본문은 반환 할 식에 대해서 작성한다. { return if(a>b) a else b }
• 코틀린은 함수를 본문이 아닌 식으로 쓸 수 있다.

  코틀린의 if는 문이 아니라 식이다. (물론 문으로도 활용 가능하다) 식은 값을 만들어 내며 다른 식의 하위 요소로 계산에 참여 할 수 있는 반면 문은 자신을 둘러싸고 있는 가장 안쪽 블록의 최상위 요소로 존재하며 아무런 값을 만들어내지 않는다는 차이가 있다.

  위 예제를 식으로 변경하면 
  fun max(a:Int,b:Int) = if(a>b) a else b
  로 이용 할 수 있다.

• 타입추론을 통해 컴파일러가 타입을 분석해 프로그래머 대신 프로그램 구성 요소 정해준다.

변수

• 자바와 반대로 변수를 타입(자료형 또는 클래스) 선언을 앞이 아닌 뒤에 선언해준다.

• 코틀린은 타입 생략이 가능하다. 대신 초기화값을 입력 해야 한다.

  val a = "가나다라마바사" //타입 생략
  val a:String = "가나다라마바사" // 타입 명시

  식이 본문인 함수와 마찬가지로 컴파일러가 초기화 식을 분석해서 타입 추론을 해준다.

• 변경 가능한 변수와 변경 불가능한 변수로 나뉜다.

  1. val(값을 뜻하는 value에서 따옴): a. 변경 불가능한 참조를 저장하는 변수 b. 초기화가 되면 재 대입이 불가능하다. c. 자바로 따지면 final 변수
  2. var(변수를 뜻하는 variable에서 따옴): a. 변경 가능한 참조다. b. 변수의 값을 바꿀 수 있다. c. 자바의 일반 변수에 해당 된다. ```

• val 변수는 블록을 실행 할 때 한번만 초기화 되어야 한다. 조건에 따라 val 값을 다른 여러 값으로 초기화 할 수 있다.

  val message :String if(true){ message = "abcd" } else{ message + "efgh" }

• val 참조 자체는 불변일지라도 객체의 내부 값은 변경이 가능하다. val a = arrayList("a","b","c") //불변 참조를 선언 a.add("d") //참조가 가리키는 객체 내부를 변경

문자열 템플릿

코틀린에서 키워드 $를 통해 변수를 문자열 안에 이용이 가능하다.

val a = "world" println("hello $a")
result = hello world

$문자를 문자열에 넣고 싶으면 $ 앞에 \를 삽입해야 한다.

1. 복잡한 식은 {} 중괄호를 이용해서 문자열 템플릿안에 넣을 수 있다. ex) val apple = Apple() println ("apple color = ${apple.color()})
2. 한글 문자열 템플릿에서는 유니코드 변수 이름으로 인해 컴파일러가 오류를 내놓을 수 있다. 한글 문자열 변수를 중괄호에 넣어서 이용하는게 좋다. ex) val hello ="안녕하세요" println("korean hello = ${hello})

• 코틀린 소스코드의 확장자는 파일명.kt 이다.
• 컴파일 할 때 코틀린 소스코드를 분석해서 .class 파일을 만든다.
• 코틀린 컴파일러로 컴파일 한 코드는 코틀린 런타임 라이브러리에 의존한다.
• 코틀린으로 컴파일 한 애플리케이션을 배포 할 때는 런타임 라이브러리도 함께 배포한다.
• 메이븐(maven), 그레들(gradle), 앤트(ant) 등의 빌드 시스템을 이용한다.

• 코틀린은 타입추론을 지정하는 정적 타입 언어이다.
• 객체지향과 함수형 프로그래밍을 모두 지원한다.

  1.일급 시민 함수를 이용해 추상화가 가능하다. 2.불변 값 지원을 통해 다중 스레드 애플리케이션 개발과 테스트를 쉽게 할 수 있다.

• 런타임 라이브러리는 크기가 작고, 코틀린 컴파일러는 안드로이드 API를 특별히 지원 한다.
• 코틀린은 무료 오픈 소스이다. 주요 IDE(IntelliJ ,Eclipse, 안드로이드 스튜디오)와 빌드 시스템을 완전히 지원한다.
• 실용적이며, 안전하고, 간결하며 상호운용성이 좋다.

  1. 코틀린 설계는 일반적인 작업에 대해 잘 알려진 해법을 채택 했다.
  2. NullPointerException 오류를 방지한다.
  3. 읽기 쉽고 간결한 코드를 지원하면서 자바와 아무런 제약 없이 통합 될 수 있다.

• 자바의 코드 스타일을 동일하게 이용 할 수 있지만, 코틀린언어의 특성을 잘 활용하여 간결하고, 문제를 해결하기 위해 만들어진 실용적인 언어다.
• 젯브레인사의 IntelliJ IDE를 이용하면 간결한 구조로 바꿀 수 있는 코드 패턴을 자동적으로 감지해서 수정을 제시 한다. 이를 통해 코틀린 언어의 특성을 이해할 수 있다.

간결성

• 코틀린은 자바에 비해 코드가 간결하다.
• getter,setter, 생성자 파라미터를 필드에 대입하기 위한 로직을 묵시적으로 제공한다.(data class)
• 자바에서는 컬렉션에서 원소를 찾는 함수를 명시적으로 작성해야만 하는 코드의 양이 상당하지만 코틀린의 컬렉션 라이브러리 함수로 대처 할 수 있다.(collection function)
• 람다를 지원하기 때문에 작은 코드 블록을 라이브러리 함수에 쉽게 전달 할 수 있다.

안전성

• 코틀린은 jvm에서 실행되는 정적 타입 언어이며, 타입 안전성을 보장한다.

  jvm은 메모리 안전성을 보장한다. 버퍼 오버플로우를 방지한다. 동적으로 할당한 메모리를 잘못 사용함으로써 인해 생길 수 있는 문제를 예방 할 수 있다.

• 코틀린의 타입 시스템은 null이 될 수 없는 추적하며, NullPointerExeception 발생 할 수있는 연산을 사용하는 코드를 금지한다.

  ? 선언으로 nullable이 가능함
  
  val s:String?=null //널이 가능
  val s2:String ="" //널이 불가능

• ClassCast으로 ClassCastException을 방지해주며, 타입 검사와 캐스트를 한 연산자에 의해 이뤄진다.

  if(value is String)
   println(value.toUpperCase)

  상호운용성

• 코틀린은 기존 자바의 라이브러리, 메소드 호출, 상속, 인터페이스, 어노테이션 등을 모든걸 이용 할 수 있다.

• 대표적으로 서버(spring), 안드로이드 플랫폼 적용가능

정적 타입 지정 언어

• 자바와 마찬가지로 코틀린도 정적타입 언어(객체의 필드나 메소드를 사용 할때 컴파일러가 타입을 입증)
• 코틀린은 자료형을 명시 할 필요 없이 변수 타입을 자동으로 유추 가능. (타입 추론)

   var count = 0

• 정적 타입 지정의 장점

  1. 성능 : 실행 시점에 어떤 메소드를 호출 할지 알아내는 과정이 필요 없으므로 메소드 호출이 더 빠름

• 2. 신뢰성* : 컴파일러가 정확성을 검증하기 떄문에 프로그램 오류로 중단될 가능성이 적어짐
• 3. 유지 보수성* : 객체가 어떤 타입인지 알 수 있기 때문에 코드 다룰 때도 쉬워짐
• 4. 도구 지원* : 도구(IDE,Web)를 통해 정확한 코드 완성을 제공해줘 더 안전하게 리팩토링이 가능하다.

함수형 프로그래밍 이용

• 일급객체 함수: 함수를 일반 값처럼 다룰 수 있다.

  일급객체 함수 조건 :

1.함수를 변수에 저장할 수 있음. 2.함수를 인자로 다른 함수에 전달 할 수 있어야함 3.함수에서 새로운 함수를 만들어서 변환 가능.

• 불변성 : 함수가 만들어지면 내부 상태가 절대로 바뀌지 않는 불변 객체를 사용해 프로그램을 작성한다.

• 부수 효과 없음 : 입력이 같으면 항상 같은 출력을 내놓고 다른 객체의 상태를 변경하지 않고, 함수 외부나 다른 바깥 환경과 상호작용하지 않는 순수 함수를 이용 한다.

• 함수형 프로그래밍의 장점 :

  1. 간결성 : 함수를 값처럼 활용할 수 있으며 더 강력한 추상화를 할 수 있고 이를 사용 해 코드 중복을 막을 수 있다.

• 2. 다중 스레드를 사용해도 안전하다* : 불변 데이터 구조를 사용하고 순수 함수를 데이터 구조에 적용한다면 같은 다중 스레드 환경에서 같은 데이터를 여러 스레드가 변경 할 수 없음. 따라서 복잡한 동기화를 적용하지 않아도 된다.

• 3. 테스트 용이 * : 부가적인 함수 없이 순수함수로 독립적으로 테스트가 가능하다.

    -순수 함수 예시-
    fun findAlice() = findPerson{it.name =="Alice"} 
    fun findBob() = findPerson{it.name =="Bob"}
  

### 무료오픈소스
- 코틀린 언어와 컴파일러, 라이브러리 및 코틀린 관련된 모든 도구는 무료로 이용이 가능하고 아파치2 라이선스하에 제공 된다. 개발은 github을 통해 이뤄지고 있으며, 인텔리 제이, 이클립스 같은 오픈소스 IDE를 활용 할 수 있다.