여러 개의 루틴을 동시에 실행하는 방법

코루틴 (coroutine)

import kotlinx.coroutines.*

코루틴은 제어 범위 및 실행 범위 지정 가능 → 코루틴의 Scope

GlobalScope

프로그램의 어디서나 제어, 동작 가능한 기본 범위

CoroutineScope

특정한 목적의 Dispatcher 를 지정하여 제어, 동작 가능한 범위

Dispatcher

Dispatchers.Default - 기본적인 백그라운드 동작 Dispatcher.IO - 네트워크나 디스크 등 I/O에 최적화된 동작 Dispatcher.Main - 메인( UI ) 스레드에서 동작 모든 플랫폼에서는 지원되지 않으니 지원되는 플랫폼에 따라 사용해야 함

val scope = CoroutineScope(Dispatcher.Default)
val coroutineA = scope.launch { }  →  반환 값이 없는 Job 객체 ( 람다함수의 형태 )
val coroutineB = scope.async { }  →  반환 값이 있는 Deffered 객체 ( 람다함수의 형태 - 마지막 구문 반환 )

코루틴은 제어되는 스코프 또는 프로그램 전체가 종료되면 함께 종료되기 때문에 코루틴이 끝까지 실행되는 것을 보장하려면 일정한 범위에서 코루틴이 모두 실행될 때까지 기다려야함

runBlocking { } 을 이용하여 프로그램이 종료되기 전 잠시 기다리며 블록을 실행 함

※ 안드로이드에서는 메인 스레드에서 runBlocking 을 걸어주면
일정 시간 응답이 없는 경우 ANR 이 발생하여 앱이 강제 종료됨

루틴의 대기를 위한 추가 함수

delay(milisecond: Long)

milisecond 단위로 루틴을 잠시 대기 시킴

Job.join()

Job 실행이 끝날때까지 대기하는 함수

Deferred.await()

Deferred 의 실행이 끝날때까지 대기하는 함수 Deferred 의 결과도 반환함

세 함수 delay() / join() / await() 는 코루틴 내부 또는 runBlocking{ } 과 같은 루틴의 대기가 가능한 구문 안에서만 동작 가능

코루틴 중단

cancel()

1. 코루틴 내부의 delay() 함수 또는 yield() 함수가 사용된 위치까지 수행된 뒤 종료
2. cancel() 로 인해 속성인 isActive 가 false 가 되므로 이를 확인하여 수동으로 종료

제한시간 내에 수행되면 결과물을 아니면 null 반환

withTimeoutOrNull( milisecond: Long ){
    구문
    결과 값
}

이 함수도 blocking 함수

풀코드

import kotlinx.coroutines.*

fun main() {

    blocking_function()

    println()
    println("====================")
    println()

    _cancel()

    println()
    println("====================")
    println()

    _withTimeoutOrNull()

}

fun blocking_function() {

    runBlocking {
        val a = launch {
            for (i in 1..5) {
                println(i)
                delay(1000)
            }
        }

        val b = async {
            "async 반환"
        }

        println("async 대기")
        println(b.await())

        println("launch 대기")
        a.join()
        println("launch 종료")

    }

}

fun _cancel() {

    runBlocking {
        val a = launch {
            for (i in 1..5) {
                println(i)
                delay(1000)
            }
        }

        val b = async {
            "async 반환"
        }

        println("async 대기")
        println(b.await())

        println("launch 취소")
        a.cancel()
        println("launch 종료")

    }

}

fun _withTimeoutOrNull() {

    runBlocking {
        val a = withTimeoutOrNull(50){
//        실패
//        val a = withTimeoutOrNull(500){
//        성공

            for(i in 1..10){
                println(i)
                delay(10)
            }
            "결과 값"
        }
        println(a)
    }

}

//async 대기
//1
//async 반환
//launch 대기
//2
//3
//4
//5
//launch 종료
//
//====================
//
//async 대기
//1
//async 반환
//launch 취소
//launch 종료
//
//====================
//
//1
//2
//3
//4
//null

정수형 변수를 10진법 대신 2진법으로 연산할 수 있는 단위

실무에서는 계산에서는 거의 사용하지 않으며 정수형의 값을 비트 단위로 나누어 데이터를 좀 더 작은 단위로 담아 경제성을 높이기 위한 용도로 사용 ( 2진법을 이용한 연산 최적화가 필요하다면 컴파일러의 기능을 사용하는 경우가 대부분 )

변수 하나에 여러 개의 값을 담아 사용하는 등으로 사용

단, 비트연산을 사용하는 부하도 무시할 수 없으므로 주로 플래그 값을 처리하거나 네트워크에서 프로토콜의 데이터 양을 줄이기 위해 자주 사용됨

좌측으로 갈 수록 상위비트 우측으로 갈 수록 하위비트

코틀린은 모든 정수형이 부호를 포함하므로 최상위 비트를 부호비트로 사용하기 때문에 데이터를 담지 않는 것이 좋음

bitwise shift operator

부호 비트를 제외한 모든 비트를 밀어주는 기능

좌측으로 밀어주는 shl 우측으로 밀어주는 shr 부호비트를 포함하여 우측으로 밀어주는 ushr

bitwise operator

둘 다 1인 경우 1을 반환하는 and → 특정 위치에 1이 있는지 확인하는 용도 → 특정 위치를 0으로 만드는 용도

둘 중 하나만 1인 경우 1을 반환하는 or → 특정 위치를 1로 만드는 용도

두 비트가 다른 경우 1을 반환하는 xor → 특정 위치가 동일한지 확인하는 용도

inv() 함수

비트를 모두 반전시키는 함수

풀코드

※ 출력 시 처음으로 1이 등장한 비트부터 출력

fun main() {

    var bitData: Int = 0b10000

    println(bitData.toString(2))

    bitData = bitData or (1 shl 2)
    println(bitData.toString(2))
//    00001 ( 1 )
//    00100 ( 1 shl 2 )
//    10000 [ bitData ]
//    10100 ( bitData or (1 shl 2) )

    var result = bitData and (1 shl 4)
    println(result.toString(2))
//    00001 ( 1 )
//    10000 ( 1 shl 4 )
//    10100 [ bitData ]
//    10000 ( bitData and (1 shl 4) )

    println(result shr 4)
//    00001 ( result shr 4 )
//    1 [ 10진수로 출력 ]

    bitData = bitData and ((1 shl 4).inv())
    println(bitData.toString(2))
//    00001 ( 1 )
//    10000 ( a shl 4 )
//    01111 ( (1 shl 4).inv() )
//    10100 [ bitData ]
//    00100 ( bitData and ((1 shl 4).inv()) )

    println((bitData xor (0b10100)).toString(2))
//    00100 ( bitData )
//    10100 ( 0b10100 )
//    10000 ( bitData xor (0b10100)) )

}

//10000
//10100
//10000
//1
//100
//10000

열거형

여러 가지 상태를 구분하기 위한 객체들을 이름을 붙혀 여러 개 생성해 두고, 그 중 하나의 상태를 선택하여 나타내기 위한 클래스

상태는 대문자를 사용하는 것이 관례

Enum 의 객체들은 고유한 속성을 가질 수 있음

생성자를 만들어 속성을 갖도록 하면, 객체를 선언할 때 속성 설정 가능

일반 클래스처럼 함수 추가 가능

객체 추가 마지막 부분에 ;(세미콜론)을 추가한 후 함수 기술하면 됨

풀코드

fun main() {

    _state()

}

fun _state() {

    var a = state.SING
    println(a)

    a = state.EAT
    println(a.messeage)

    a=state.SLEEP
    println(a.isSleeping())


}

enum class state(val messeage: String) {
    SING("sing"),
    EAT("eat"),
    SLEEP("sleep");

    fun isSleeping() = this == state.SLEEP
}

5가지 기능을 내부적으로 자동으로 생성

1. equals() - 내용의 동일성 판단

2. hashcode() - 객체의 내용에서 고유한 코드 생성

3. toString() - 포함된 속성을 보기 쉽게 나타냄

4. copy() - 객체를 복사하여 똑같이 내용의 새 객체를 만듦

※ 파라미터 없이 생성할 수도 있고,
  파라미터를 전달하여 일부 속성 교체 가능

5. componentX() - 속성을 순서대로 반환

※ 배열이나 리스트 등에 Data Class 객체가 담겨 있을 때
  이 내용을 자동으로 꺼내 쓸 수 있는 기능을 지원하기 위한 함수

풀코드

fun main() {

    equals_hashcode_tostring()

    println()
    println("====================")
    println()

    _componextX()

}

fun equals_hashcode_tostring() {

    val a = General("name1", 1)

    println(a == General("name1", 1))
    println(a.hashCode())
    println(a)

    println()

    val b = Data("name2", 2)

    println(b == Data("name2", 2))
    println(b.hashCode())
    println(b)

    println()

    println(b.copy())
    println(b.copy("name3"))
    println(b.copy(id = 3))

}

fun _componextX() {

    val llist = listOf(
            Data("name11", 1),
            Data("name12", 2),
            Data("name13", 3)
    )

    for ((a, b) in llist) {
        println("$a : $b")
    }

}

class General(val name: String, val id: Int)

data class Data(val name: String, val id: Int)

클래스의 인스턴스를 단 하나만 만들어 사용하도록 하는 코딩 아키텍처 패턴

object 오브젝트명 { ... }

오브젝트명.속성
오브젝트명.함수()

fun main() {
    println(Counter.count)

    Counter.add()
    println(Counter.count)
    Counter.add()
    println(Counter.count)

    Counter.clear()
    println(Counter.count)
}

object Counter{
    var count=0

    fun add(){
        count++
    }

    fun clear(){
        count=0
    }
}

companion object

클래스 내의 오브젝트 (static 과 비슷함)

companion object { ... }

클래스명.속성
클래스명.함수()

fun main() {
    var a = JJ("짜장")
    var b = JJ("짬뽕")

    a.vote()
    a.vote()

    b.vote()
    b.vote()
    b.vote()

    println("짜장 투표수 : ${a.count}")
    println("짬뽕 투표수 : ${b.count}")
    println("최종 투표수 : ${JJ.total}")
}

class JJ(val name: String) {
    companion object {
        var total = 0
    }

    var count = 0
    fun vote() {
        total++
        count++
    }
}

//짜장 투표수 : 2
//짬뽕 투표수 : 3
//최종 투표수 : 5

패키지 / 클래스 / 함수에서 적용되는 개년

패키지 안에서 변수, 함수, 클래스들이 하나의 스코프 함수 / 클래스 안에서 변수, 함수들이 하나의 스코프

특징) 외부에서는 내부 멤버를 참조 연산자(.)로 참조 가능 동일 스코프 내에서 멤버 공유 하위 스코프에서 상위 스코프 멤버 재정의

접근제한자

변수(속성), 함수, 클래스 앞에 붙여 제한

패키지

public        어떤 패키지에서도 접근 가능
internal    같은 모듈 내에서 접근 가능
private        같은 파일에서 접근 가능

클래스

public        클래스 외부에서도 접근 가능
private        클래스 내부에서만 접근 가능
protected    클래스 자신, 상속받은 클래스에서 접근 가능

스코프 함수

클래스에서 생성한 인스턴스 → 스코프 함수를 통해 따로 작업 가능 인스턴스에서의 참조 연산자 사용 없이 구문 작성 가능 속성이나 함수를 좀 더 깔끔하게 불러 사용할 수 있다 → main 함수와 별도의 스코프에서 작업 수행 → 코드 단순화

fun main() {

    val price=99999

    var a = Book("코틀린", 10000).apply {
        name = "[초특가] " + name
        discount()
//        price -= 5000
    }

    a.run {
        println(name)
        println("$price")
    }

    with(a){
        println(name)
        println("$price")
    }

    a.also {
        it.price -= 5000
    }

    a.let {
        println(it.name)
        println("${it.price}")
    }

}

class Book(var name: String, var price: Int) {
    fun discount() {
        price -= 2000
    }
}

apply

초기화와 동시에 수행

클래스를 생성과 동시에 구문이 수행됨

var a = 클래스명(초기화).apply { 수행할 구문 }

run

마지막 구문 반환 이미 인스턴스가 만들어진 후 인스턴스의 속성, 함수를 스코프 내에서 사용할 때 유용

a.run { 수행할 구문 }

with( 인스턴스 )

run 기능과 동일

with(a){ 수행할 구문 }

also

apply 와 같은 기능 main 에서의 속성과 ㅎ마수의 속성 이름이 같을 때, 구분하기 위해 'it' 을 사용해 구분

a.also { 
    ...
    it.price -= 5000
    ...
}

let

run 과 같은 기능 main 에서의 속성과 ㅎ마수의 속성 이름이 같을 때, 구분하기 위해 'it' 을 사용해 구분

var a = 클래스명(초기화).apply { 수행할 구문 }

속성 + 함수 인스턴스를 만드는 틀

클래스의 파라미터는 속성 + 생성자

class 클래스명 (파라미터) {
    ...
    fun 함수명 (파라미터) { ... }
    ...
}

fun main(){
    var 인스턴스명 = 클래스명(파라미터 초기화)

    인스턴스명.함수명(인자)
}

생성자

인스턴스의 속성 초기화 + 생성 시 구문 수행

class 클래스명(파라미터){
    init { ... } // 생성 시 바로 수행되는 함수
}

※ 보조 생성자

constructor에서의 this에 의해 init이 가장 먼저 수행됨

class 클래스명(파라미터){
    init { ... } // 생성 시 바로 수행되는 함수
    constructor (파라미터) : this (파라미터, 고정 값) { ... }
}

상속

기존의 클래스의 멤버를 확장하기 위한 목적으로 상, 하 구조를 가지도록 구성하는 것

슈퍼 클래스

open class ...

서브 클래스

class 서브 클래스명 (일부 파라미터) : 슈퍼 클래스명 ( ... ) { ... }

풀코드

fun main() {
    var SUPER = Super()
    println(SUPER.a)

    println()

    var SUB = Sub()
    println(SUB.a)
    println(SUB.b)
}

//1
//
//1
//11

open class Super {
    val a = 1
}

class Sub : Super() {
    val b = 11
}

오버라이딩

슈퍼 클래스에 open을 붙이고 서브 클래스에서 override를 붙여 이름과 형태가 같은 함수 재정의 가능

fun main() {
    var SUPER = Super()
    println(SUPER.a)
    SUPER.superfunc()

    println()

    var SUB = Sub()
    println(SUB.a)
    println(SUB.b)
    SUB.superfunc()
    SUB.subfunc()
}

//1
//super fun
//
//1
//11
//override super fun
//sub fun

open class Super {
    val a = 1
    open fun superfunc(){
        println("super fun")
    }
}

class Sub : Super() {
    val b = 11
    override fun superfunc() {
        println("override super fun")
    }
    fun subfunc(){
        println("sub fun")
    }
}

추상화

형식만 선언하고 실제 구현을 서브 클래스에 일임

추상 클래스, 함수에는 반드시 'abstract' 키워드를 붙여야 함 상속 받은 클래스에서 재정의 가능

fun main() {
    var b = B()
    b.a()
    b.b()
}

abstract class A() {
    abstract fun a()
    fun b() {
        println("fun b")
    }
}

class B : A() {
    override fun a() {
        println("override fun a")
    }
}

//override fun a
//fun b

인터페이스

abstract 와 달리 생성자가 없음 Java와 달리 구현된 일반 함수도 구현 가능, 속성도 선언 가능 → abstract 와 open 키워드가 필요 없음 → 서브 클래스에서 override를 이용해 모두 구현, 재정의 가능

※ 여러 인터페이스를 하나의 서브 클래스에 상속 받는 것이 가능해 유연한 코딩(구현) 가능

인터페이스 A, B를 한 번에 C로 상속 가능

클래스 C를 인스턴스로 생성하여 함수 a, b, c 사용 가능

fun main() {
    var c = C()
    c.a()
    c.b()
    c.c()
}

interface A {
    fun a()
}

interface B {
    fun b()
    fun c() {
        println("fun c")
    }
}

class C : A, B {
    override fun a() {
        println("override fun a")
    }

    override fun b() {
        println("override fun b")
    }
}

다형성

fun main() {
    var 변수1: 클래스1 = 클래스2()
    변수1.함수1()
//    변수1.함수2()

    println()

    var 변수2 = 클래스2()
    변수2.함수1()
    변수2.함수2()

    println()

    if (변수1 is 클래스1) {
        var 변수3 = 변수1 as 클래스2
        변수3.함수1()
        변수3.함수2()
    } else {
        println("...")
    }
}

open class 클래스1 {
    open fun 함수1() {
        println("구문1")
    }
}

class 클래스2 : 클래스1() {
    override fun 함수1() {
        println("구문1 재정의")
    }

    fun 함수2() {
        println("구문2")
    }
}

//구문1 재정의
//
//구문1 재정의
//구문2
//
//구문1 재정의
//구문2

up-casting

< 하위 클래스가 상위 클래스화 되는 것 >

var 인스턴스: 상위 클래스 = 하위 클래스()

상위 클래스화 하기 위해서 인스턴스의 클래스 타입 지정

※ 인스턴스의 클래스 타입을 지정하지 않으면
  자동으로 하위 클래스로 추론됨

down-casting

< 상위 클래스화 된 인스턴스를 지정한 하위 클래스화 하는 것 >

is와 as 키워드 사용

if (인스턴스 is 클래스) → 인스턴스의 클래스 확인용 조건에 사용

var 인스턴스 = 존재하는 인스턴스 as 하위 클래스 up-casting 된 인스턴스를 하위 클래스로 캐스팅

is 로 조건을 걸어서 as 로 down-casting 하는 방법이 일반적

while (조건) { ... }

do { ... } while (조건)

범위 (반복 횟수)

for (인덱싱 변수명 in 시작..끝 step 증가량) { ... } //시작부터 끝까지 증가량씩 증가
for (인덱싱 변수명 in 시작douwnTo끝 step 증가량) { ... } //끝부터 시작까지 증가량씩 감소

'step 증가량' 이 없는 경우 1씩 증감

흐름제어

반복문 ( ... ) {
    ...
    break //반복문 종료
    continue //다시 반복 조건 확인
    ...
}

이름 부여 (label)

반복문에 이름( label ) 부여하여 유연한 흐름제어

이름@반복문1 ( ... ) {
    반복문2 ( ... ) {
        ...
        break@이름 //반복문2 안에서 반복문1을 바로 종료
        continue@이름 //바로 반복문1의 다음 조건 확인
        ...
    }
}

if (조건식)
{
    실행문
} 
else if (조건식)
{
    실행문
}
else {
    실행문
}

비교 연산자

< <= > >= == !=

l-value 와 r-value 비교

!is is

l-value 의 자료형이 r-value 와 일치하는지 확인

다중 조건문 (when)

when(변수){
    데이터 -> 구문 //데이터와의 일치여부
    (!)is 자료형 -> 구문 //자료형 확인
    ...
    else -> 구문 //모든 조건과 맞지 않을 때 (마지막에 else는 반드시 필요)
}

구문 부분에 데이터를 반환하여 when()의 결과를 데이터로 사용가능 ( var 변수2 = when(변수){ ... } )

파라미터와 자료형은 타입추론 불가능

fun 함수명(파라미터):자료형 { 
    ... 
    return 반환값 //종료
    ... 
}

fun main(){
    함수명(인자)
}

단일 표현식 함수

fun 함수명(파라미터) = 반환식

고차함수

함수를 마치 클래스에서 만들어낸 인스턴스처럼 취급하는 방법 함수를 파라미터로 넘기거나 결과 값을 반환 받을 수도 있음 모든 함수는 고차함수로 이용 가능

fun main() {
    b(::a)
}

fun a(str:String){
    println("$str 함수 a")
}

fun b(function:(String)->Unit){
    function("b가 호출한")
}

//b가 호출한 함수 a

b(::a)

function = a function("b가 호출한")

str = "b가 호출한" println("b가 호출한 함수 a")

람다함수

자체가 고차함수 별도의 연산자 없이도 변수에 담을 수 있음

fun main() {
    val c: (String) -> Unit = { str: String -> println("$str 람다함수 a") }
    val cc: (String) -> Unit = { str -> println("$str 람다함수 a") }
    val ccc = { str: String -> println("$str 람다함수 a") }

    b(c)
    b(cc)
    b(ccc)
}

fun b(function: (String) -> Unit) {
    function("b가 호출한")
}

//b가 호출한 람다함수 a
//b가 호출한 람다함수 a
//b가 호출한 람다함수 a

a 함수 없이 람다함수로 작성 가능

1. '->' 이후 부분에 여러 구문 작성 가능 '->' 이후 부분의 반환 값이 존재하는(Unit이 아닌) 경우, 마지막 구문이 반환됨
2. 파라미터가 없는 경우, 구문만 작성('->' 없이)
3. 파라미터가 1개인 경우, 'it'으로 대체 가능

오버로딩

같은 스코프 안에서 서로 다른 파라미터를 가진 같은 이름의 함수를 사용하는 방법

※ 파라미터의 종류와 갯수가 중요함. 이름이 다른 것은 상관 없음

fun main() {

    A(10)
    A("문자열")

}

fun A(x: Int) {
    println("$x")
}

fun A(x: String) {
    println(x)
}

Argument (인자)

default argument

굳이 입력하지 않아도 기본 값이 있는 파라미터를 가진 함수를 만드는 방법

fun main() {

    B("지정 문자열1")
    B("지정 문자열1", 88)
    B("지정 문자열1", 99, "지정 문자열2")

}

fun B(a: String, b: Int = 1, c: String = "기본 문자열") {
    println("$a\t$b\t$c")
}

named argument

순서대로 인자를 입력하지 않고 사이의 값을 기본갑으로 설정하기 위해서 설정할 파라미터의 이름을 지정하여 설정하는 방법

fun main() {

    B("지정 문자열1", c = "지정 문자열2")

}

fun B(a: String, b: Int = 1, c: String = "기본 문자열") {
    println("$a\t$b\t$c")
}

variable number of argument (vararg)

같은 자료형을 개수에 상관없이 파라미터로 받을 때 사용하는 방법

※ vararg 와 다른 파라미터를 함께 사용하는 경우 마지막에 작성

fun main() {

    C("문자열", 1, 1, 1, 1)

}

fun C(str: String, vararg numbers: Int) {
    var sum = 0

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

    println("$str, $sum")
}

infix 함수

연산자처럼 쓸 수 있는 함수

※ class 안에서 infix 함수를 선언할 때에는 적용할 클래스가 자기 자신이므로 클래스의 이름을 쓰지 않는다

fun main() {

    println(6 D 4)
    println(6.D(4))

}

infix fun Int.D(x: Int): Int = this * x

Array<T> var 배열명 : Array<자료형> = arrayOf(1,2,3,4,...) → (튜플)안에 데이터를 지정하여 정해진 개수 및 데이터의 배열 생성

fun main(args: Array<String>) {
    var array_1: Array<Int> = arrayOf(1, 2, 3, 4, 5)

    array_1.forEach { print(it) }
}

var 배열명 : Array<자료형?> = arrayOfNulls<자료형>(크기) → 크기가 정해진 배열 생성 (데이터는 추후에 입력 가능) 배열명[인덱스] = 데이터 의 방법으로 입력

fun main(args: Array<String>) {
    var array_1: Array<Int?> = arrayOfNulls<Int>(5)
    array_1[0] = 1
    array_1[1] = 2
    array_1[2] = 3
    array_1[3] = 4
    array_1[4] = 5

    array_1.forEach { print(it) }
}

Int형 정수를 0 부터 채우는 배열

var 배열명 : Array<자료형> = Array<자료형>(크기) {임시변수 -> 임시변수}

fun main(args: Array<String>) {
    var array_1: Array<Int> = Array<Int>(5) { i -> i }

    array_1.forEach { print(it) }
}

그 외의 자료형

var 배열명 : Array<자료형> = Array<자료형>(크기) {임시변수 -> 임시변수.to자료형()}

fun main(args: Array<String>) {
    var array_1: Array<String> = Array<String>(5) { i -> i.toString() }

    array_1.forEach { print(it) }
}

일반적으로 var 을 사용하여 선언 val 을 이용하여 초기화한 경우 변경 불가능 (Java 의 final)

선언 방법 var 변수명 : 자료형 = 초기값 (null 사용 불가) var 변수명 : 자료형? = 초기값 (null 사용 가능)

자료형

정수형

0b : 2진수 0x : 16진수

( 8 bit) Byte (16 bit) Short (32 bit) Int - 기본형 (64 bit) Long - 데이터 끝에 'L' 붙이기

실수형

지수 표기법 가능

(32 bit) Float - 데이터 끝에 'f' 붙이기 (64 bit) Double - 기본형

문자형

(2 Byte) - Char - UTF-16 BE

논리형

(1 bit) - Boolean - true / false

문자열

String "..." - 기본 """...""" - 작성한 모양대로 출력

반환 값 없음

Unit

형변환

암시적 형변환 불가능 명시적 형변환으로 사용 -> 변수명.to자료형()

타입추론

정수

10, 2, 16 진수는 Int 가 기본 정수에 'L' 을 붙이면 Long 으로 인식

실수

Double 이 기본 실수에 'f' 를 붙이면 Float 로 인식

논리형

Boolean 이 기본

문자

Char 가 기본

증감 연산자

전위

(++변수 / --변수) 증감이 적용된 상태로 문장 수행

후위

(변수++ / 변수--) 문장이 끝한 후 증감 적용

논리 연산자

true / false 를 비교하여 true / false 값 도출

AND : && OR : || NOT : !

고급

val 은 할당된 객체를 바꿀 수 없을 뿐, 객체 내부 속성을 변경 가능

상수

컴파일 시점에 결정되어 절대 변경 불가능한 값 const val 으로 선언

상수로 선언될 수 있는 값은 String 을 포함한 기본 자료형만 가능하며 런타임에 생성될 수 있는 일반적인 다른 클래스의 객체들은 담을 수 없음

클래스의 속성이나 지역 변수 등으로 사용 불가능

반드시 companion object 안에 선언하여 객체의 생성과 관계없이 클래스와 관련된 고정적인 값으로만 사용해야함

이름은 의례적으로 대문자와 언더바를 사용한 표기법

☞ 변수의 경우 런타임시 객체를 생성하는데 시간이 더 소요되어 성능의 하락이 있기 때문에 늘 고정적으로 사용할 값은 상수를 통해 객체 생성 없이 메모리에 값을 고정하여 사용하여 성능을 향상시킬 수 있는 장점이 있음

늦은 초기화 ( lateinit )

변수 선언 시, 객체를 바로 할당하지 않으면 컴파일이 되지 않음 변수에 객체를 할당하는 것을 선언과 동시에 할 수 없는 경우도 있음

이런 경우, lateinit var 으로 변수를 선언하고 초기값의 할당을 나중에 진행할 수 있도록 하는 키워드

※ 초기값 할당 전까지 변수 사용 불가능 ( 에러 발생 ) ※ 기본 자료형에는 사용 불가능 ( String 에는 가능 )

※ ::변수.isInitialized → lateinit 변수에 초기값이 할당 되었는지 확인 가능

지연 대리자 속성 ( lazy delegate properties )

변수를 사용하는 시점까지 초기화를 자동으로 늦춰주는 기능 val 변수 : 자료형 by lazy { 초기값 }

코드에서 선언 시 즉시 객체를 생성 및 할당하여 변수를 초기화하는 형태를 갖고 있지만 실제 실행 시에는 변수를 사용하는 시점에 초기화하여 코드의 실행시간 최적화 가능

람다 함수로 초기화가 진행되므로 여러 개의 구문이 들어갈 수 있으며 마지막 구문이 변수에 할당됨

풀코드

fun main() {
    _constant()
    println()
    println("=========================")
    println()
    _lateinit()
    println()
    println("=========================")
    println()
    _lazy()
}

fun _constant() {
    val foodCourt = FoodCourt()

    foodCourt.searchPrice(FoodCourt.FOOD_CREAM_PASTA)
    foodCourt.searchPrice(FoodCourt.FOOD_STEAK)
    foodCourt.searchPrice(FoodCourt.FOOD_PIZZA)
}

class FoodCourt {
    fun searchPrice(foodName: String) {
        val price = when (foodName) {
            FOOD_CREAM_PASTA -> 13000
            FOOD_STEAK -> 13000
            FOOD_PIZZA -> 13000
            else -> 0
        }
        println("$foodName : $price")
    }

    companion object {
        const val FOOD_CREAM_PASTA = "크림파스타"
        const val FOOD_STEAK = "스테이크"
        const val FOOD_PIZZA = "피자"
    }
}

fun _lateinit() {
    val a = LateInitSample()
    println(a.getLateIntitText())

    a.text = "새로운 값"
    println(a.getLateIntitText())
}

class LateInitSample {
    lateinit var text: String

    fun getLateIntitText(): String {
        if (::text.isInitialized) {
            return text
        } else {
            return "기본값"
        }
    }
}

fun _lazy() {
    val number: Int by lazy {
        println("초기화")
        7
    }

    println("코드 시작")
    println(number)
    println(number)
}

//크림파스타 : 13000
//스테이크 : 13000
//피자 : 13000
//
//=========================
//
//기본값
//새로운 값
//
//=========================
//
//코드 시작
//초기화
//7
//7

토스: SLASH 22

라인:

카카오:

네이버:

우아한 형제들:

넥슨:

구글:

2023

2024

2025

2026

2027

2028

2029

2030

OpenAPI (JSON) https://kobis.or.kr/kobisopenapi/webservice/rest/boxoffice/searchDailyBoxOfficeList.json?key=f5eef3421c602c6cb7ea224104795888&targetDt=20220614

• 상위 10개 항목 -> 1컬럼 리스트로 표현
• 전날대비 순위 등락 표현 (+0 / - / -0)

2. 유류 가격 확인

OpenAPI (XML) http://www.opinet.co.kr/api/avgAllPrice.do?out=F220425120&code=F220425120

• 고급휘발류, 자동차용경유, 휘발유, 실내등유, 자동차용부탄
• 전날대비 가격 등락 표현 (+0.00 / - / -0.00)

var 키워드 사용

var num = 5            // 5
num = 1                // 1 // 값 수정 가능

상수

let 키워드 사용

let name = "Jason"    // Jason
name = "Jay"          // Jay   // 값 수정 불가능

String

"" 으로 선언

let quote = "I'm mother father genius, Man" // I'm mother father genius, Man

Integer

정수형 숫자 표현

let num = 5                  // 5
let otherNum = num + 2       // 7
let halfOfNum = otherNum / 2 // 3

내장함수

let num = 360                                 // 360

// 3의 배수인지 확인하는 메소드
print(num.isMultiple(of: 3))                  // true

// 0~300 사이중 랜덤으로 수를 뽑아내는 메소드
let random = Int.random(in: 0...300)          // ..랜덤

Double

소수점을 포함한 숫자

let score = 3.6 // 3.6

Boolean

참.거짓 표현

let isMan = true    // true
let isHuman = false // false

var isSingle = true // true
isSingle.toggle()   // false
isSingle            // false

String Interpolation

데이터를 문자열로 표현

let difficulty = "쉽다" // 쉽다
let maximumAge = 80     // 80

let message = "\(maximumAge) 할머니도 배우는 iOS 개발은 \(difficulty)" 
// "80 할머니도 배우는 iOS 개발은 쉽다"

배열, 딕셔너리

데이터를 묵어 표현 [ ] 으로 선언

// Array
let ages = [3, 20, 60]                  // [3, 20, 60]
let colors = ["green", "red", "yellow"] // ["green", "red", "yellow"]

let color = colors[0]                   // "green"

// Dictionary (Key: Value)
let languageCode = [
    "한국" : "ko",
    "미국" : "en",
    "일본" : "ja",
]                                       //  ["한국" : "ko", "미국" : "en", "일본" : "ja" ]

let code = languageCode["한국"]          // "ko"

비어있는 배열, 딕셔너리 초기화

// Array
var emptyArr: [Int] = []          // []

// Dictionary (Key: Value)
var emptyDic: [String: Any] = [:] // [:]

enum

서로 관계있는 값을 모아 표현한 것 특정 타입을 표시하기 좋음

// 요일을 한번 enum으로 만들어 보겠습니다. 
enum WeekDay {
    case mon
    case tue
    case wed
    case thu
    case fri
}

var today: WeekDay = .mon


// 미디어타입을 한번 enum으로 만들어 보겠습니다. 
enum MediaType {
    case audio
    case video
}

var mediaType: MediaType = .audio