코틀린 문법

메인함수

fun main() {
    print("Hello")
}

 

 

변수&상수

fun main() {
    var i = 10
    var name = "킴"
    var point = 3.14
}

코틀린은 타입추론이 된다. 아래와 같은 코드

fun main() {
    var i:Int =10
    var name:String ="킴"
    var point:Double = 3.14
    
    //상수는 var 대신 val
    val num = 20
}

 

 

톱 레벨 상수 const val

자바와 달리 main함수밖으로 상수를 뺄 수 있다.

이를 톱 레벨 상수라 한다. main()보다 우선으로 컴파일 된다. 

const val num = 20
fun main() {
    
}

 

 

형변환

fun main() {
    var i = 10
    var l = 20L

    l = i //오류. 타입이 다르면 들어가지 않는다.
    
    //타입 캐스팅이 필요하다
    l = i.toLong()
    i = l.toInt()

}

fun main() {
    var i = 10
    var name = "10"
    name = i.toString()
}

 

 

String

fun main() {
    val name = "hello"
    println(name)
    println(name.uppercase())
    println(name.lowercase())
    println(name[0])
    println("제 이름은 ${name+10} 입니다.")
}

실행결과
hello
HELLO
hello
h
제 이름은 hello10 입니다.

 

 

max,min

import kotlin.math.max

fun main() {
    val i = 10
    val j = 20
    print(max(i,j))
}

 

 

random

import kotlin.random.Random

fun main() {
    val randomNumber = Random.nextInt()
    print(randomNumber)
}

실행결과
1263993763

fun main() {
    //from 0 until 100
    //from은 inclusive, until은 exclusive
    //따라서 0~99까지 수 중 렌덤
    val randomNumber = Random.nextInt(0,100)
    print(randomNumber)
}

 

 

키보드 입력

아래 두 코드는 같은 결과지만, 세부적인 차이가 있다.

Scanner는 'java.util'패키지에 속하는 자바 클래스, 읽는 부분과 타입 변환 따로 해야함

readln().toInt()을 사용하는 것이 더 편리하고 간결한 방법일 수 있습니다.

fun main() {
    print("A입력")
    val a:Int = readln().toInt()
    print("B입력")
    val b:Int = readln().toInt()
    print(a+b)
}

fun main() {
    //in은 코틀린에서 사용 못하는 키워드이므로 `` 로 묶어준다.
    val reader = Scanner(System.`in`)
    reader.nextInt()
    reader.next()
}

 

 

조건문

fun main() {
    var i = 5
    if (i > 10) {
        print("10보다 크다")
    }else if ( i > 5){
        print("5보다 크다")
    } else{
        print("x")
    }
}

//Command키로 if<->when 변환 가능하다.
fun main() {
    var i = 5
    when {
        i > 10 -> {
            print("10보다 크다")
        }
        i > 5 -> {
            print("5보다 크다")
        }
        else -> {
            print("x")
        }
    }
}

조건식 자체를 값에 넣을 수 있다. if문이 아니라 식!! 자바에서는 불가능하다

fun main() {
    var i = 5
    var result = if (i > 10) {
        "10보다 크다"
    }
    else if (i > 5) {
        "5보다 크다"
    }
    else {
        "x"
    }
    print(result)
}

fun main(){
    //boolean result = i > 10 ? true : false;     //자바에서 삼항연산

    val i = 5
    val result = if ( i > 10 ) true else false
}

반복문

fun main(){
    val items = listOf(1,2,3,4,5)
    for(item in items){
        print(item)
    }
}
아래와 같은 코드
fun main(){
    val items = listOf(1,2,3,4,5)
    items.forEach { item ->
        print(item)
    }
}

fun main(){
    for ( i in 0..3 ){
        print(i)
    }
}

실행결과
0123

fun main(){
    val items = listOf(1,2,3,4,5)
    for ( i in 0..(items.size-1)){
        print(i)
    }
}

실행결과
01234

while, break, continue는 자바와 동일하다

 

List

fun main(){
    //리스트는 불변. 가져다 쓸 수만 있다.
    val items = listOf(1,2,3,4,5)

    //가변
    val item = mutableListOf(1,2,3,4,5)
    
    //위 코드와 같다. 코틀린은 타입추정을 할 수 있으므로 아래와 같은 부분은 생략한다.
    val item : MutableList<Int> = mutableListOf<Int>(1,2,3,4,5)

    item.add(6)
    item.remove(3)

}

 

Array

fun main(){
    //배열은 가변
    val items = arrayOf(1,2,3)
    items[0] = 10
    for( i in items) {
        println(i)
    }
}

실행결과
10
2
3

 

예외처리

fun main(){
    val items = listOf(1,2,3)

    try{
        val item = items[4]
    }catch(e: Exception){
        print(e.message)
    }

}

실행결과
Index 4 out of bounds for length 3

 

Null Safety

fun main(){
    var name: String = null //오류
	
    널을 넣을 수 잇는 타입은 타입 뒤에 ? 넣어야함
    var name: String? = null

    name = "kim"
    name = null
    
}

fun main(){
    var name: String? = null 
    var name2: String = ""
    
    //?가 붙은거와 안붙은거는 별도 타입으로 처리. 따라서 아래문장은 에러
    name2 = name //에러
    name = name2 //이거는 정상 동작, name이 더 큰 범위임. 잘 생각해보자
}

 

if문으로 nullCheck

fun main(){
    var name: String? = null
    var name2: String = ""
	
    //아래와 같이 nullCheck를 해줘야한다.
    if (name != null) {
        name2 = name //name이 String타입으로 변환되는 것
    }
 }

 

!!으로 널체크

fun main() {
    var name: String? = null 
    var name2: String = ""

    // ?를 떼는방법 '!!'
    //하지만 이 코드는 개발자가 임의로 null이 아님을 보증했기에 좋지 않은 코드
    name2 = name!!
}

 

코틀린에서 제공하는 내장함수 이용

fun main() {
    var name: String? = null
    name = "kim"
    name = null
    var name2: String = ""

    //"null이 아니라면 이 블록을 실행하자"라는 문장
    name?.let{
        name2 = name
    }
}

 

 

함수

탑 레벨 함수: 맨 바깥에 선언한 함수로 어느 파일에서나 사용 가능하다.

fun main(){
    print(sum(10,20))
}

fun sum(a: Int, b: Int) : Int {
    return a + b
}

한줄코드는 아래처럼 사용가능하다.
fun sum(a: Int, b: Int) : Int = a + b

추론가능할 경우 리턴 생략 가능, input타입은 반드시 지정해야한다.
fun sum(a: Int, b: Int) : Int = a + b

오버로딩

fun main(){
    print(sum(10,20))
}

fun sum(a: Int, b: Int, c:Int = 0) : Int = a + b +c

------------------------------------------------------
메소드를 여러 개 만드는 것이 아닌, 파라미터를 조정해서 사용한다.
아래,위 코드 모두 가능하다.

fun main(){
    print(sum(10,20,30))
}

fun sum(a: Int, b: Int, c:Int = 0) : Int = a + b +c

fun main(){
    print(sum(a=10,b= 20)) //순서 중요x. b=10,a=20 넣어도 된다.
}

fun sum(a: Int, b: Int, c:Int = 0) : Int = a + b +c

 

 

class

fun main(){
    val john = Person("John",20)
    print(john.name)
    print(john.age)
}

클래스의 기본생성자를 바로 작성한다. 
class Person(val name: String, var age: Int){

}

fun main(){
    val john = Person("John",20)
    print(john.name)
    print(john.age)
}

처음에 생성자에서 전달하고 외부에 노출 시키지 않겠다.: private
class Person(
    private val name: String,
    var age: Int
)

 

 

data class

fun main(){
    val john = Person("John",20)
    val john2 = Person("John",20)

    print(john == john2) //다른 객체이므로 '==' 시 false
}
class Person(
    val name: String,
    var age: Int
)

자바처럼 내용이 같으면 같은 결과를 내도록 하려면 eqauls와 hashcode를  재정의 하면 된다.

fun main() {

    val john = Person("John", 20)
    val john2 = Person("John", 20)

    println(john)
    println(john2)
    println(john == john2)
}
    class Person(
        val name: String,
        var age: Int
    )

실행결과
Person@33c7353a
Person@681a9515
false

둘이 다른 객체임을 알 수 있다.

재정의 귀찮다. 코틀린은 아주 간단한 방법이 있다. 그것은 data class

fun main() {

    val john = Person("John", 20)
    val john2 = Person("John", 20)

    println(john)
    println(john2)
    println(john == john2)
}
data class Person(
        val name: String,
        var age: Int
    )

실행결과
Person(name=John, age=20)
Person(name=John, age=20)
true

fun main() {

    val john = Person("John", 20)
    val john2 = Person("John", 20)

    println(john)
    println(john2)
    println(john == john2)
}
class Person(
        val name: String,
        var age: Int
    )//생성자로 파라미터 받고 끝이 아니라 작업을 더 하고 싶다면
{
    init{
        print("init")
    }
}

fun main() {

    val john = Person("John", 20)
    val john2 = Person("John", 20)

    println(john)
    println(john2)
    println(john == john2)
    john.hobby ="ddd" //외부에서 변경가능
}
class Person(
        val name: String,
        var age: Int
    )//생성자로 파라미터 받고 끝이 아니라 작업을 더 하고 싶다면
{
    var hobby = "축구"
    init{
        print("init")
    }
    fun some(){
        hobby = "농구"
    }

}

 

 

getter,setter

fun main() {

    val john = Person("John", 20)
    val john2 = Person("John", 20)

    println(john)
    println(john2)
    println(john == john2)
    john.hobby ="ddd" //private set이므로 오류
}
class Person(
        val name: String,
        var age: Int
    )
{
    var hobby = "축구"
        private set //setter
    init{
        print("init")
    }
    fun some(){
        hobby = "농구"
    }

}

fun main() {

    val john = Person("John", 20)
    val john2 = Person("John", 20)

    println(john)
    println(john2)
    println(john == john2)
    println(john.hobby)
}
class Person(
        val name: String,
        var age: Int
    )//생성자로 파라미터 받고 끝이 아니라 작업을 더 하고 싶다면
{
    var hobby = "축구"
        private set //setter
        get() ="취미: $field" //getter
    init{
        print("init")
    }
    fun some(){
        hobby = "농구"
    }

}

실행결과
initinitPerson@33c7353a
Person@681a9515
false
취미: 축구

 

 

상속,extends

자바는 기본적으로 허용되는 컨셉, 코틀린은 반대

상속을 받아도 오버라이딩이 안된다.

fun main() {
}

abstract class Animal{
    fun move(){
        print("이동")
    }
}
class Dog: Animal(){
    move //에러
}

class Cat: Animal(){

}

open키워드를 사용해서 허용해준다. 그 후 오버라이딩 진행

fun main() {
}

abstract class Animal{
    open fun move(){
        print("이동")
    }
}
class Dog: Animal(){
    override fun move() {
        println("껑충")
    }
}

class Cat: Animal(){
    override fun move() {
        println("살금")
    }
}

기본적으로 일반 클래스는 상속이 불가  ->open키워드

fun main() {
}

class Person

class SuperMan: Person() //에러

fun main() {
}

open class Person

class SuperMan: Person()

 

 

interface

fun main() {
}

interface Drawable{
    fun draw()
}

abstract class Animal{
    open fun move(){
        print("이동")
    }
}
class Dog: Animal(),Drawable{ //인터페이스는 ()가 안 붙는다.
    override fun move() {
        println("껑충")
    }

    override fun draw() { //미구현된 메소드 오버라이딩
        TODO("Not yet implemented")
    }
}

 

 

 

타입 체크 is

fun main() {
    val dog = Dog()
    val cat = Cat()

    if(dog is Dog){
        println("멍멍이")
    }
}

실행결과
멍멍이

fun main() {
    val dog:Animal = Dog()
    val cat = Cat()

    if(dog is Dog){
        println("멍멍이")
    }
}

실행결과
멍멍이

실제로 Dog()로 만들었으므로 가능하다.

fun main() {
    val dog:Animal = Dog()
    val cat = Cat()

    if(dog is Animal){
        println("멍멍이")
    }
}

실행결과
멍멍이

이것도 맞다.

 

 

강제 타입변환 as

fun main() {
    val dog:Animal = Dog()
    val cat = Cat()

    cat as Dog
    if(dog is Dog){
        
        println("멍멍이")
    }
}

 

 

제너릭

fun main(){
    val box = Box(10)
    val box2 = Box("dfdf")

    print(box.value)
}
class Box<T>(var value: T){

}

 

 

콜백함수(고차함수)

fun main(){
    myFunc ({
        println("함수 호출")
    })
}

fun myFunc(callBack: () -> Unit){ //인풋, 아웃풋 모두 없는 함수
    println("함수 시작")
    callBack()
    println("함수 끝")

}

실행결과
함수 시작
함수 호출
함수 끝

코틀린에서 전달하는 인자가 함수인 경우 -> 그 함수는 밖으로 뺄 수 있다.

fun main(){
    myFunc ({
        println("함수 호출")
    })
}

같은 코드
//람다식
fun main(){
    myFunc (){
        println("함수 호출")
    }
}

 

suspend함수

함수앞에 suspend키워드 : 정지함수

suspend함수가 되면 ▶밑에 →가 생긴다. 

일반적인 메인 함수에서 실행 안된다.

suspend함수는 다른 suspend함수 안에서 실행 가능하다.

main을 suspend로 만드는건 올바른 방법이 아니므로 코루틴 스코프(CoroutineScope)를 만들어 사용한다.