[Kotlin] 코틀린 문법 기초 1

프로젝트에서 Kotlin을 사용해서 간단한 문법 정리를 하고자 한다. 

자바를 접해본 사람은 러닝 커브가 낮다고 하는데 ..

코틀린을 활용하는 몇몇 기업도 있으니 이번 기회에 한 번 학습해봐야겠다 생각했다 . .

 

 

변수

(val | var) 변수명 : 반환타입 = 변수에 담을 값

• 변수 선언

val a : Int = 1

• 타입 생략

val b = 1

• 지연 할당

val c : Int // 타입 명시 필수
c = 3

---

✴️ val, var 차이

🔹val (value) : 자바의 final 키워드처럼 한 번 초기화 후에는 다시 초기화 X
🔹var (variable) : 가변 변수이므로 초기화 후에도 다시 변경 가능 👉 var로 선언하더라도 타입은 고정됨

 

• 컴파일 오류 

val d : String = "Hello"
d = "World" // 컴파일 오류 발생

var e = 12
e = "hi" // Int 타입을 String으로 변경하면 컴파일 오류

• 탑-레벨 변수 선언 가능 

val PI = 3.14159        // 불변 탑-레벨 변수
var counter = 0         // 가변 탑-레벨 변수

fun incrementCounter() {
    counter += 1
}

fun main() {
    println("PI: $PI")
    println("Initial counter: $counter")
    
    incrementCounter()
    println("Counter after increment: $counter")
}

 

 

 

함수

fun 함수명(인자: 타입, 인자: 타입) : 반환타입 {
    return 결과 
}

👉 함수 정의할 때 fun 키워드 사용 

• 함수 선언

// 몸통이 있는 함수는 반환타입을 제거하면 컴파일 오류
fun sum(a: Int, b: Int) : Int {
	return a + b
}

• 함수 본문은 표현식이 될 수 있음

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

• 표현식이면서 반환 타입 생략 👉 반환타입이 없어도 컴파일러가 분석하여 적절한 타입 추론

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

• 반환형이 없는 경우 Unit이 반환타입이 됨 (≒ Java의 void)

// Unit 생략 가능
fun printSum(a: Int, b: Int): Unit {
	println("$a 더하기 $b = ${a + b}")
}

• 디폴트 파라미터

fun greeting(message: String = "안녕하세요!") {
	println(message)
}

fun main() {
	greeting() // 안녕하세요!
    greeting("Hello World") // Hello World
}

• named argument

fun log(level: String = "INFO", message: String) {
	println("[$level]$message")
}

fun main() {
    log(message = "인포 로그")
    log(level = "DEBUG", "디버그 로그")
    log("WARN", "워닝 로그")
    log(level = "ERROR", message = "에러 로그")
}

👉 코틀린의 함수는 자바의 메서드보다 간결하게 작성 가능하고 named argument나 default parameter 기능이 유용함 

 

 

 

흐름 제어 

• if..else : 표현식으로서 그 자체로 값을 만들어낼 수 있음

val job = "Software Engineer"
if (job == "Software Engineer") {
    println("개발자임")	
} else {
    println("개발자아님")
}

val age : Int = 18
val str = if (age > 18) {
	"성인"
} else {
	"아이"
}
println(str)

👉 표현식이므로 삼항 연산자 X

 

• when : Java의 switch문과 비슷

when (대상변수) {
    조건 -> 참인 경우 실행
    조건 -> 참인 경우 실행
    조건 -> 참인 경우 실행
   else -> 참인 조건이 없을 경우 실행
}

val day = 2
val result = when (day) {
    1 -> "월요일"
    2 -> "화요일"
    3 -> "수요일"
    4 -> "목요일"
    5 -> "금요일"
    6 -> "토요일"
    7 -> "일요일"
    else -> "에러"
}
println(result)
// 화요일

• else 생략 가능
• 여러 개의 조건을 콤마로 구분해 한 줄에서 정의 가능

fun getNumber() = 2
fun main() {
    when (getNumber()) {
        0, 1 -> print("number == 0 or number == 1")
        else -> print("0과 1이 아닌 경우")
    }
    // "0과 1이 아닌 경우"
}

• for loop : Java의 foreach와 유사 

•  .. 범위 연산자 

for (i in 0..3) {
	println(i)
}
// 0
// 1
// 2
// 3

 

• until : 뒤에 온 숫자 포함 X

for (i in 0 until 3) {
	println(i)
}
// 0
// 1
// 2

 

• step : 들어온 값만큼 증가시킴

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

 

• downTo : 반복하면서 값 감소시킴

for (i in 3 downTo 1) {
	println(i)	
}
// 3
// 2
// 1

 

• 전달받은 배열 반복 

val numbers = arrayOf(1, 2, 3)

for (i in numbers) {
	println(i)
}
// 1
// 2
// 3

• while loop

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

 

 

null 안정성 

🔶 자바의 Optional은 값을 래핑하기 때문에 객체 생성에 따른 오버헤드 발생하고, 컴파일 단계에서 null 가능성 검사 X
🔶 코틀린 👉 null 가능성을 컴파일러가 미리 감지해서 NPE 가능성을 줄임 

val a : String = null // 컴파일 오류

var b : String = "aabbcc"
b = null // 컴파일 오류

var a : String? = null
a.length // a 변수는 nullable하므로 참조시 컴파일 오류

a?.length // 안전 연산자 -> 컴파일 오류 사라짐
println(a?.length) // null 출력

val b : Int = if(a!=null) a.length else 0

// 엘비스 연산자 -> 좌변이 null인 경우 우변 리턴
val b = a?.length ?: 0

fun getNullStr(): String? = null

fun getLengthIfNotNull(str: String?) = str?.length ?: 0 // 엘비스 연산자

fun main() {
    val nullableStr = getNullStr()
    val nullableStrLength = nullableStr?.length ?: 0
    println(nullableStrLength)
}