개요
이 글은 Java 문법이 익숙하고 Kotlin 문법이 헷갈리는 사람(나)를 위해 정리한 글이다.
아주 빠르게 훑어보자
변수
val a = 10 // Int 로 타입 추론
var b = 10
b = 20 // var 변수는 재할당 가능
null
var x: Int? = 10
x = null // ? 는 nullable 타입
?. !!.
var str: String? = null
println(str?.uppercase())
str = "abc"
println(str!!.uppercase())
function
fun add(x: Int, y: Int): Int {
return x + y
}
fun add(x: Int, y: Int) = x + y // 리턴 타입 생략 + 한 줄 표현
기본 자료형
- 숫자형
- Double
- Float
- Long
- Int
- Short
- Byte
val a = 1 // Int - 기본
val b = 3000000000 // Long - 21억 초과 시 자동 Long
val c = 1L // Long - suffix L
val d: Byte = 1 // Byte - 쩔수
val e = 3.14 // Double - 기본
// val f: Double = 1 // Error - type mismatch
val g = 3.1415926535 // Float - 6~7 자리 초과
val h = 3.14f // Float - suffix f- 문자형
- String
- Char
- longStr
- 배열
- Array<타입>
- arrayOf() // 생성과 동시 초기화
반복문
val numbers = arrayOf(1, 2, 3, 4, 5)
var sum = 0
for (n in numbers) {
sum += n
}
print("sum : $sum")for (i in 1 .. 10) { // 1 ~ 10
println(i)
}
for (i 10 downTo 1) {
println(i)
}
for (i in 1 .. 10 step 2) {
println(i)
}
for (i in 1 until 10) { // 1 ~ 9
println(i)
}- while은 너무 똑같아 생략
조건문
- if문은 너무 똑같아 생략
val bigger = if (a>b) a else b // 바로 대입 가능// java 의 switch case 문은 when 으로 대체
when (x) {
1 -> println("일")
5 -> println("오")
else -> println("?")
}
// 마찬가지로 직접 대입 가능
val num = when (x) {
1 -> "일"
2 -> "이"
3 -> "삼"
}
lateinit
lateinit var text: String // 굳이 null로 초기화해놓지 말고 lateinit 하자
val a = 1
text = "text $a"
val b = 2
text = "text $a $b"lateinit은 값이 계속 변경될 수 있다는 속성이라 반드시var을 사용해야 하고,- 숫자형(Int Float 등)에는 사용할 수 없다.
by lazy
lateinit var text: String
val textLength: Int by lazy {
text.length
}
text = "asdf"
println(textLength)- 선언 당시 초기화할 수 없지만, 호출 시 어떻게 초기화할지 정의해주는 것
- 따라서
val만 사용
클래스
인스턴스 생성
class Person {
}
fun main() {
val person = Person() // new 필요 없음!!
}
프로퍼티 선언
class Person {
var name: String = "" // 클래스 선언과 동시 초기화 필수
var age: Int = 0
}생성자 선언
class Person {
constructor (name: String, age: Int) {
this.name = name
this.age = age
}
var name: String = ""
var age: Int = 0
}
// 축약
class Person (name: String, age: Int) {
var name: String = ""
var age: Int = 0
}// 기본 값 지정
class Person (name: String, age: Int = 20) {
var name: String = name
var age: Int = age
}
val p1 = Person("김인간") // age는 자동 20// 한 줄로 또 축약 + 기본 값 지정
class Person (var name: String = "이름", var age: Int = 20)
val p2 = Person()
상속
open class Fruit {}
class Apple: Fruit() {} // Fruit 를 상속받은 Apple- 상속 불가능이 default이기 때문에 open 필수!
내부 클래스
class Student {
var name: String = "John"
init {
println("name : $name")
}
inner class Personality {
fun doSomething(): Unit {
name += ", the king of everything..."
println(name)
}
}
}
fun main() {
val student = Student()
student.Personality().doSomething()
}inner키워드를 붙여 클래스 내부에서 사용
컬렉션
List
listOf()- 불변형 리스트, 원소 변경 불가
val list1: List<String> = listOf("one", "two")
// 사실 List<String> 통째로 생략 가능 (타입 추론)
val list2 = listOf(1, "one", 2, "two")
// Any 타입으로 추론됨
// 원소 접근
println("last el of list1 : ${list1[1]}")
// 원소 순회
for (el in list1) println(el)mutableListOf()- 가변형 리스트, add, remove, 변경 가능
val list3: MutableList<String> = mutableListOf<String>("one", "two")
// 사실 타입 생략 가능
val list4 = mutableListOf("one", "two") // 이게 가장 축약된 버전
list4.add("three")
list4.removeAt(1)
list4[0] = "ONE"
println(list4) // [ONE, three]Set
val set1: Set<Int> = setOf<Int>(1,2,3)
val set2 = setOf(1,2,3) // 축약- 불변형 set -
setOf() - 가변형 set -
mutableSetof(),hashSetOf(),sortedSetOf(),linkedSetOf()
Map
val map1: Map<Int, String> = mapOf(11 to "one", 22 to "two")
// 축약 생략
print(${map1[22]})
print(${map1.get(22)})
print(${map1.keys})- 불변형 map -
mapOf() - 가변형 map -
mutableMapOf(),hashMapOf(),sortedMapOf(),linkedMapOf()
참고문서
[Kotlin] 코틀린 기본문법1 (변수선언/함수선언/자료형/반복문/조건문)
