코틀린

변수 (Variable)

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) // 가변

조건문 / 반복문 (Conditional Statement / Loop Statement)

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	파일 내부에서만 이용	클래스 내부에서만 이용

클래스 세부 개념 (Class Detail Concepts)

데이터 클래스 (Data Class)

// 객체의 데이터를 비교할 때 사용
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)

// singleton을 만들 때 사용
object User {

    val name = "John Doe"

    fun printName() {
        println(name)
    }
}

val name = User.name // "John Doe"
User.printName()     // 출력: "John Doe"

익명 클래스 (Anonymous Class)

// 인터페이스로 구현
interface OnClickListener {
    fun onClick()
}

val button = object : OnClickListener {
    override fun onClick() {
        println("Button clicked")
    }
}

button.onClick()

// 추상 클래스 확장
abstract class Shape {
    abstract fun draw()
}

val rectangle = object : Shape() {
    override fun draw() {
        println("Drawing a rectangle")
    }
}

rectangle.draw()

// 객체 표현식
open class Printer {
    open fun print() {
        println("Printing...")
    }
}

val printer = object : Printer() {
    override fun print() {
        println("Custom Printing...")
    }
}

printer.print()

컴패니언 클래스 (Companion Class)

// 클래스 이름으로 멤버에 접근할 때 사용
class User {
    companion object {

        val name = "John Doe"

        fun printName() {
            println(name)
        }
    }

    ...
}

val name = User.name // "John Doe"
User.printName()     // 출력: "John Doe"

람다 함수 (Lambda Function)

람다 함수 (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)
}

널 연산자 (Null Operator)

var variable: String? = null       // 널 허용 타입으로 선언

var length = variable?.length      // 변수가 null이면 null 반환, 아니면 멤버에 접근

var length = variable?.length ?: 0 // 변수가 null이면 두번째 값, 아니면 첫번째 값 반환

var length = variable!!.length     // 변수가 null이면 예외 발생

출처: 강성윤, 「Do it! 깡샘의 안드로이드 앱 프로그래밍 with 코틀린」, 이지스퍼블리싱