변수
val / var
val variable: Int = 0 // 초기값 변경 불가능
var variable: Int = 0 // 초기값 변경 가능
타입(Type)
val variable: Int = 0
val variable: Short = 0
val variable: Long = 0L
val variable: Double = 0.0
val variable: Float = 0.0f
val variable: Byte = 0b0000
val variable: Boolean = true
val variable: Char = 'a'
val variable: String = "Hello\n" // """도 사용 가능
// String 안에 다른 값을 포함해야 할때 ${} 이용
val variable: Any = Class() // 최상위 클래스, 모든 타입 가능
fun f(): Unit{ // 반환문이 없는 함수에 사용
println("함수 실행")
}
fun f(): Nothing{ // null이나 예외를 반환하는 함수에 사용
return null
}
fun f(): Nothing{
throw Exception()
}
lateinit / lazy
lateinit var variable: String // var 키워드를 사용한 변수만 사용 가능
// Int, Long, Short, Double, Float, Boolean, Byte 타입은 사용 불가능
val variable: Int by lazy { // 마지막 줄의 실행 결과가 초기값이 됨
println("초깃값 할당")
0
}
null 허용
var variable: Int = 0 // null 불허용
var variable: Int? = null // null 허용
Collection
Array
val array: Array<Int> = Array(3) {0} // Array(배열 크기) {초기값 설정 함수}
val array: Array<Int> = arrayOf<Int>(0, 0, 0) // 초기값 설정
val array: IntArray = IntArray(3) {0} // Array(배열 크기) {초기값 설정 함수}
val array: IntArray = intArrayOf(0, 0, 0) // 초기값 설정
// ShortArray, LongArray, FloatArray, DoubleArray, ByteArray, BooleanArray, CharArray도 비슷하게 사용 가능
List
val list: List<Int> = listOf<Int>(0, 0, 0) // 불변
val list: MutableList<Int> = mutableListOf<Int>(0, 0, 0) // 가변
Set
val set: Set<Int> = setOf(0, 0, 0) // 불변
val set: MutableSet<Int> = mutableSetOf(0, 0, 0) // 가변
Map
val map: Map<Int, Int> = mapOf(Pair(0, 0), 0 to 0) // 불변
val map: MutableMap<Int, Int> = mutableMapOf(Pair(0, 0), 0 to 0) // 가변
조건문 / 반복문
if / else if / else 조건문
if (condition > 10){
println("첫번째 조건 실행")
} else if (condition > 0){
println("두번째 조건 실행")
} else{
println("세번째 조건 실행")
}
val variable = if (condition > 10){ // 마지막 줄의 실행 결과를 반환
println("첫번째 조건 실행")
0
} else if (condition > 0){
println("두번째 조건 실행")
1
} else{
println("세번째 조건 실행")
2
}
when 조건문
when (condition) {
0 -> println("첫번째 조건 실행")
1 -> println("두번째 조건 실행")
else -> println("세번째 조건 실행")
}
when { // 데이터를 명시하지 않고 사용 가능
condition > 10 -> println("첫번째 조건 실행")
condition > 0 -> println("두번째 조건 실행")
else -> println("세번째 조건 실행")
}
val variable = when { // 마지막 줄의 실행 결과를 반환
condition > 10 -> {
println("첫번째 조건 실행")
0
}
condition > 0 -> {
println("두번째 조건 실행")
1
}
else -> {
println("세번째 조건 실행")
2
}
}
for 반복문
for (i in 1..10){
variable += i
}
/*
for (i in 1..10) -> 1부터 10까지 1씩 증가
for (i in 1 until 10) -> 1부터 9까지 1씩 증가
for (i in 1..10 step 2) -> 1부터 10까지 2씩 증가
for (i in 10 downTo 1) -> 10부터 1까지 1씩 감소
for (i in collection) -> collection 요소
for (i in collection.indices) -> collection 인덱스
for ((index, value) in collection.withIndex()) -> collection 인덱스, 요소
*/
while 반복문
while (i < 10){
i += 1
}
함수(Function)
fun function(param1: Int, param2: Int): Int {
...
return variable
}
클래스(Class)
생성자(Constructor)
class Person(val firstName: String, val lastName: String) { // 주 생성자
// var, val을 붙이면 init이나 constructor 외의 구역에서도 parameter을 사용 가능
var fullName: String = ""
var age: Int = 0
init {
this.fullName = "$firstName $lastName"
}
// 보조 생성자
constructor(firstName: String, lastName: String, age: Int) : this(firstName, lastName) {
this.fullName = "$firstName $lastName"
this.age = age
}
}
val person1 = Person("John", "Doe")
val person2 = Person("Alice", "Smith", 30)
상속(Inheritance) / 오버라이딩(Overriding)
open class Animal(val name: String) { // 부모 클래스, open을 사용하여 상속 허용
// open을 사용하여 오버라이딩 허용
open fun makeSound() {
println("Animal makes a sound")
}
}
class Dog(name: String) : Animal(name) { // 자식 클래스
// 자식 클래스에서 부모 클래스의 메서드를 오버라이드(재정의)
override fun makeSound() {
println("Dog barks")
}
}
접근 제한자(Visibility Modifier)
| 접근 제한자 |
최상위에서 이용 |
클래스 멤버에서 이용 |
| public |
모든 파일에서 가능 |
모든 클래스에서 가능 |
| internal |
같은 모듈 내에서 가능 |
같은 모듈 내에서 가능 |
| protected |
사용 불가 |
상속 관계의 하위 클래스에서만 가능 |
| private |
파일 내부에서만 이용 |
클래스 내부에서만 이용 |
클래스 종류
데이터 클래스
// 객체의 데이터를 비교할 때 사용
data class User(val id: Long, val name: String, val email: String)
val user1 = User(1, "John Doe", "john@example.com")
val user2 = User(1, "John Doe", "john@example.com")
val str = user1.toString() // "User(id=1, name=John Doe, email=john@example.com)"
val isEqual = user1 == user2 // true
// 주 생성자의 멤버 변수가 같은지 판단
val code1 = user1.hashCode() // 99313359
val code2 = user2.hashCode() // 99313359
싱글톤
// singleton을 만들 때 사용
object User {
val name = "John Doe"
fun printName() {
println(name)
}
}
val name = User.name // "John Doe"
User.printName() // 출력: "John Doe"
익명 클래스
// 인터페이스로 구현
interface OnClickListener {
fun onClick()
}
val button = object : OnClickListener {
override fun onClick() {
println("Button clicked")
}
}
button.onClick()
// 추상 클래스 확장하기
abstract class Shape {
abstract fun draw()
}
fun main() {
val rectangle = object : Shape() {
override fun draw() {
println("Drawing a rectangle")
}
}
rectangle.draw()
}
// anonymous class을 만들 때 사용
val user: User = object: User {
val name = "John Doe"
fun printName() {
println(name)
}
}
val name = user.name // "John Doe"
user.printName() // 출력: "John Doe"
컴패니언 클래스
// 클래스 이름으로 멤버에 접근할 때 사용
class User {
companion object {
val name = "John Doe"
fun printName() {
println(name)
}
}
...
}
val name = User.name // "John Doe"
User.printName() // 출력: "John Doe"
람다 함수 (Lambda Function)
람다 함수
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y } // 보통의 람다 함수
val greet: () -> Unit = { println("안녕하세요!") } // 매개변수가 없는 람다 함수
val square: (Int) -> Int = { it * it } // 매개 변수가 1개인 람다 함수
// it 키워드 사용 가능
val multiply: (Int, Int) -> Int = { x, y -> // 마지막 줄이 반환값
val result = x * y
result
}
typealias
typealias MathOperation = (Int, Int) -> Int
fun calculate(x: Int, y: Int, operation: MathOperation): Int {
return operation(x, y)
}
널 연산자
var variable: String? = null // 널 허용 타입으로 선언
var length = variable?.length // 변수가 null이면 null 반환, 아니면 멤버에 접근
var length = variable?.length ?: 0 // 변수가 null이면 두번째 값, 아니면 첫번째 값 반환
var length = variable!!.length // 변수가 null이면 예외 발생