#1 ์ฝํ๋ฆฐ์ ํจ์๋ ์ผ๊ธ ๊ฐ์ฒด๋ค
์ผ๊ธ ๊ฐ์ฒด - ์ํค๋ฐฑ๊ณผ, ์ฐ๋ฆฌ ๋ชจ๋์ ๋ฐฑ๊ณผ์ฌ์
์ํค๋ฐฑ๊ณผ, ์ฐ๋ฆฌ ๋ชจ๋์ ๋ฐฑ๊ณผ์ฌ์ . ์ปดํจํฐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ๋์์ธ์์, ์ผ๊ธ ๊ฐ์ฒด(์์ด: first-class object)๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์ ์ผ๋ฐ์ ์ผ๋ก ์ ์ฉ ๊ฐ๋ฅํ ์ฐ์ฐ์ ๋ชจ๋ ์ง์ํ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํจ๋ค. ๋ณดํต
ko.wikipedia.org
์ฝํ๋ฆฐ์์๋ ํจ์๋ฅผ ์ผ๊ธ ๊ฐ์ฒด(First-class object)๋ก ์ทจ๊ธํ๋ค. ์ฝํ๋ฆฐ์์ ํจ์๋ฅผ ์ผ๊ธ ๊ฐ์ฒด๋ก ์ทจ๊ธํ๋ค๋ ๊ฒ์ ํจ์๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด๋ค๊ณผ ๋๋ฑํ๊ฒ ๋ค๋ฃจ์ด์ง๊ณ , ๋ค์ํ ์ฐ์ฐ์ ์ ์ฉํ ์ ์๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค. ๊ทธ๋ ๋ค๋ฉด, ํจ์์ ๋ฐ์ดํฐ ํ์ ๋ํ ์กด์ฌํ ๊ฒ์ด๋ค. val s : String์์ s๋ ๋ฐ์ดํฐ ํ์ ์ด String์ธ ๊ฐ์ฒด์ธ ๊ฒ์ฒ๋ผ, ์ด String์ ์ญํ ์ ํ๋ ํจ์ ๋ฒ์ ํ์ ๋ง์ด๋ค.
#2 ํจ์ ํ์ ํํ์์ ๋ฌธ๋ฒ
#2-1 ๊ธฐ๋ณธ ๋ฌธ๋ฒ
fun myFunction(value1: Int, value2: Int): Int {
return value1 * value2 + 8
}
fun main() {
val functionReference: (Int, Int) -> Int
// ๋๋ธ์ฝ๋ก (::)์ ์ฝํ๋ฆฐ์์ ํจ์, ํด๋์ค, ๋ฉค๋ฒ ํจ์, ์์ฑ์ ๋ฑ์ ์ฐธ์กฐํ๋ ๋ฐ์ ์ฌ์ฉํ๋ ๊ธฐํธ
functionReference = ::myFunction
println(functionReference(7, 9)) // ์ถ๋ ฅ ๊ฒฐ๊ณผ: 71
}
ํจ์ ํ์ (Function types) ํํ์์ (๋งค๊ฐ๋ณ์'๋ค') -> ๋ฆฌํด ํ์ ์ ํํ๋ก ํจ์์ input๊ณผ output๋ฅผ ๊ธฐ์ ํ๋ค. ์๋ฅผ ๋ค์ด val f : (Int, Int) -> Int์์ f๋ ๋งค๊ฐ๋ณ์๋ก Int, String์ ๋ฐ๊ณ return ํ์ ์ Int์ธ ํจ์๋ค. ๋ง์ฝ ์ ์ฝ๋์์ functionReference์ ํจ์ ํ์ ํํ์์ด myFunction๊ณผ ๋ฌ๋๋ค๋ฉด myFunction์ ์ฐธ์กฐํ ์ ์์์ ๊ฒ์ด๋ค.
#2-2 ๋งค๊ฐ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ
val functionReference: () -> Int
๋งค๊ฐ๋ณ์๊ฐ ์๋ค๋ฉด ()์ ๊ฐ์ด ํจ์ ํ์ ํํ์์ ๊ดํธ ์์ ์๋ฌด๊ฒ๋ ๋ฃ์ง ์์ผ๋ฉด ๋๋ค.
#2-3 return์ ํ์ง ์๋ ๊ฒฝ์ฐ
val functionReference: (Int, Int) -> Unit
ํจ์ ํ์ ํํ์์์ ํจ์์ return์ด ์๋ ๊ฒฝ์ฐ return ํ์ ์๋ฆฌ์ Unit์ ๋ฃ๋๋ค. Unit์ ์๋ฐ์ void์ ๋์๋๋ ํค์๋๋ค.
#2-4 ๋งค๊ฐ๋ณ์๋ ์๊ณ return๋ ํ์ง ์๋ ๊ฒฝ์ฐ
val functionReference: () -> Unit
๋งค๊ฐ๋ณ์๋ ์๊ณ , return๋ ์๋ค๋ฉด ํด๋น ํจ์๋ () -> Unit ํ์ ์ด๋ค.
#1์์ ์ฝํ๋ฆฐ์์ ํจ์๋ฅผ ์ผ๊ธ ๊ฐ์ฒด๋ก ์ทจ๊ธํ๋ค๋ ๊ฒ์ ํจ์๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด๋ค๊ณผ ๋๋ฑํ๊ฒ ๋ค๋ฃจ์ด์ง๊ณ , ๋ค์ํ ์ฐ์ฐ์ ์ ์ฉํ ์ ์๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค๊ณ ํ์๋ค. ๋ค์์ผ๋ก ํจ์๋ฅผ ๋ค๋ฅธ ๊ฐ์ฒด๋ค๊ณผ ๋๋ฑํ๊ฒ ๋ค๋ฃฐ ๋ ํํด์ง๋ ๋ค์ํ ์ฐ์ฐ์ ์์ด๋ค.
#3 ํจ์ ๊ฐ์ฒด ์ฐ์ฐ
#3-1 ํจ์๋ฅผ ๋ณ์์ ํ ๋นํ ์ ์์
val functionReference: (Int) -> Int = fun(args: Int): Int {
return args + 1
}
fun main() {
val result = functionReference(2)
println(result) // ์ถ๋ ฅ ๊ฒฐ๊ณผ: 3
}
/* ์ ์ฝ๋์ ๊ฐ์ ๋์์ ํ๋ ๋๋ค์ ๋ฒ์ ์ฝ๋
val functionReference: (Int) -> Int = { args -> args + 1 }
fun main() {
val result = functionReference(2)
println(result)
}
*/
#2-1์ ์ฝ๋์์์ฒ๋ผ ๋ณ์์ ํจ์๋ฅผ ํ ๋นํ ์ ์๋ค. ์ฝํ๋ฆฐ์์ ์ด๋ค ํจ์๋ฅผ ์ต๋ช ํจ์๋ก ์ฐ๋ฉด์ ํด๋น ํจ์์ ์ด๋ฆ์ ๋ถ์ด๋ฉด ์๋ฌ(Anonymous functions with names are prohibited)๊ฐ ๋๋ฏ๋ก fun ํค์๋ ์ค๋ฅธ์ชฝ์ ํจ์ ์ด๋ฆ์ ์ฐ์ง ์์๋ค.
#3-2 ํจ์๋ฅผ returnํ ์ ์์
fun add(x: Int, y: Int): Int = x + y
fun getAddFunction(): (Int, Int) -> Int {
return ::add
}
fun main() {
val submit = getAddFunction()(2, 3)
println(submit) // ์ถ๋ ฅ ๊ฒฐ๊ณผ: 5
}
getAddFunction()์ return ํ์ ์ Intํ 2๊ฐ๋ฅผ ๋ฐ์ Int๋ฅผ ๋ฆฌํดํ๋ 'ํจ์'๋ค.
#3-3 ํจ์๋ฅผ ์ธ์๋ก ์ ๋ฌ ๊ฐ๋ฅ
fun calculateNumbers(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
return operation(x, y)
}
fun main() {
val result = calculateNumbers(4, 5, fun(args1, args2): Int { return args1 * args2 })
println(result) // ์ถ๋ ฅ ๊ฒฐ๊ณผ: 20
}
/* ์ ์ฝ๋์ ๊ฐ์ ๋์์ ํ๋ ๋๋ค์ ๋ฒ์ ์ฝ๋
fun calculateNumbers(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
return operation(x, y)
}
fun main() {
val result = calculateNumbers(4, 5) { args1, args2 -> args1 * args2 }
println(result)
}
*/
#3-1์์์ ๋ง์ฐฌ๊ฐ์ง๋ก, ์ธ์๋ก ์ ๋ฌ๋๋ ์ต๋ช ํจ์์ ์ด๋ฆ์ ๋บ๋ค.
#4 ์์ฝ
ํจ์๋ฅผ ์ผ๋ฐ ๋ฐ์ดํฐ ๊ฐ์ฒด์ฒ๋ผ ๋ค๋ฃฐ ์ ์๋ค๋ฉด, ๋น์ฐํ ํจ์์ '๋ฐ์ดํฐ ํ์ ' ๋ํ ์กด์ฌํด์ผ ํ๋ค.
'๊นจ์ ๊ฐ๋ ๐ > Kotlin' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin] Coroutines - ๊ธฐ์ด (0) | 2024.02.07 |
---|---|
[Kotlin] ๋๋ค(Lambda) ํํ์ (0) | 2024.02.01 |
[Kotlin] ํจ์ํ ์ธํฐํ์ด์ค (Single Abstract Method Interface) (0) | 2024.01.30 |
[Kotlin] ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ (Operator overloading) (0) | 2024.01.29 |
[Kotlin] ํ๋กํผํฐ(Property) (0) | 2024.01.17 |