kotlin-기본-문법

기본 출력

fun main() {
    println("Hello World!")
}

함수 생성은 fun

출력 함수는 println

; 은 붙이지 않음

---

변수 선언

fun main() {
    println("Hello World!")
    varTest()
    valTest()
}

fun varTest() {
    var num: Int
    num = 123
    println(num)
}

fun valTest() {
    val num: Int
    num = 123
    // num = 456
    println(num)
}

자료형은 `변수명: 자료형` 순서로 작성

var 은 변수 값 변경 가능

val 은 java 에서 final 변수, 변수 값 변경 불가능

한 번 할당 되면 변경이 안됨

변수 생성과 동시에 초기화를 하는 경우 타입을 적지 않아도 됨

---

null 허용

fun nullTest() {
    val _null: Int?
    _null = null
    println(_null)
}

`변수명: 자료형?` 형태로 ? 를 자료형 끝에 붙여주면

해당 변수에 대한 null 을 허용한다는 의미

붙여주지 않으면 null 을 담을 수 없음

형변환

fun typeCastingTest() {
    val num: Int = 123
    val string: String = num.toString()
    println(string)
}

---

배열

fun arrayTest() {
    val firstIntegers: Array<Int> = arrayOf(1, 2, 3)
    val secondIntegers = arrayOfNulls<Int>(5)
    val anythings: Array<Any> = arrayOf(1, "string", 1.1, 'c')
    println(firstIntegers[0])
    println(secondIntegers[1])
    println(anythings[2])
}

---

함수

fun functionTestAdd(firstNumber: Int, secondNumber: Int): Int {
    return firstNumber + secondNumber
}

fun 함수명(매개변수명: 자료형): 반환 자료형

위 형태로 기본형 함수를 생성

fun add(firstNumber: Int, secondNumber: Int): Int = firstNumber + secondNumber

위 형태로 단일 표현식 함수를 생성

---

조건문

fun ifTest(): Unit {
    val number = 7
    if (number > 6) {
        println(number)
        return
    }
    println("exit")
}

반환 타입	설명
Void	Java와의 상호 운용성을 위해 존재하며, Kotlin에서는 일반 함수에서 거의 사용되지 않음
Unit	Kotlin의 기본 반환 타입. 반환값이 없는 함수는 기본적으로 Unit을 반환
반환 타입 없음	Unit으로 간주되며, 명시하지 않아도 fun ifTest()는 암묵적으로 Unit 반환

---

is

fun isTest() {
    val number: Any = 1

    if (number is Int) {
        println("number is Int")
    }

    if (number is String) {
        println("number is String")
    }
}

자료형 비교를 위해 사용

 

when

fun whenTest(parameter: Any) {
    when (parameter) {
        1 -> println(parameter)
        "test string" -> println(parameter)
        else -> println(parameter)
    }
}

switch 와 유사

 

fun whenTest2(parameter: Any) {
    val something = when (parameter) {
        1 -> parameter
        "test string" -> parameter
        else -> parameter
    }
    println(something)
}

값을 설정하는 용도로 사용할 수도 있음

---

반복문

fun whileTest() {
    var i: Int = 0
    while (i < 5) {
        println(i++)
    }
}

fun forTest() {
    for (i in 0..3) {
        print(i)
        print(" ")
    }
    println()

    for (i in 3 downTo 0) {
        print(i)
        print(" ")
    }

    println()

    for (i in 'a'..'e') {
        print(i)
        print(" ")
    }
}

---

흐름 제어

break, continue 는 다른 언어와 동일

 

클래스

class Person(val name: String, val age: Int) {
    fun introduce() {
        println("Hi my name is $name, and age is $age")
    }
}

 

class Person(val name: String, val age: Int) {
    init {
        println("${this.name} + ${this.age}")
    }

    fun introduce() {
        println("Hi my name is $name, and age is $age")
    }
}

init 을 이용하면

인스턴스가 생성될 때 실행할 구문을 지정할 수 있음

 

class Person(val name: String, val age: Int) {
    constructor(name: String) : this(name, 23)

    init {
        println("${this.name}" + "${this.age}")
    }
}

보조 생성자인 constructor 를 오버로딩 해 생성자를 만들 수 있음

 

상속

open class Animal(val name: String, val age: Int, val type: String) {
    open fun introduce() {
        println("${this.name} ${this.age} ${this.type}")
    }
}

class Dog(name: String, age: Int) : Animal(name, age, "강아지") {
    override fun introduce() {
        println("bark")
    }
}

 

추상 클래스

abstract class Parent() {
    abstract fun eat()

    fun sniff() {
        println("parent sniffing")
    }
}

class Child(): Parent() {
    override fun eat() {
        println("child eating")
    }
}

자바와 동일

 

인터페이스

interface Runner {
    fun run()
}

interface Eater {
    fun eat() {
        println("dummy")
    }
}

class Rabbit(var number: Int) : Runner, Eater {
    override fun run() {
        println("run")
    }

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

자바와 다르게, 인터페이스라고 해서 추상 함수만으로 이루어지지 않아도 된다

생성자는 만들 수 없다

 

접근제어자

public

protected

private

 

list

fun listTest() {
    val immutable = listOf<Int>(1, 2, 3)
    val mutable = mutableListOf<Int>()

    mutable.add(1)
    mutable.add(2)
    mutable.add(3)
    mutable.add(2, 6)
    
    println(immutable)
    println(mutable)
}

---

string

fun stringTest() {
    val string = "a.b.c.d"
    println(string.length)

    var split = string.split('.')
    println(split)
	
    // array to string
    println(split.joinToString())
    println(split.joinToString("-"))

    println(string.substring(0..2))

    println(test.startsWith("a."))
    println(test.endsWith(".d"))
    println(test.contains("b.c"))
}

---

고차함수

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

fun myFunc(callBack: () -> Unit) {
	callBack()
}