# Kotlin ๊ธฐ๋ณธ ๋ฌธ๋ฒ_ํจ์ & ๋ฉ์๋์ ์ง์ญ๋ณ์, ์ ์ญ๋ณ์
# Kotlin ๊ธฐ๋ณธ ๋ฌธ๋ฒ_ํจ์
- ํจ์ ์ ์ธ (๊ธฐ๋ณธํ)
fun ํจ์๋ช
([๋ณ์๋ช
: ์๋ฃํ, ๋ณ์๋ช
: ์๋ฃํ..]) : [๋ฐํ๊ฐ์ ์๋ฃํ]
{
ํํ์
[return ๋ฐํ๊ฐ]
}
- ํจ์ ์ ์ธ(์ผ๋ฐ์ ์ ์ธ๊ณผ ๊ฐ๋ตํ ์ ์ธ)
//์ผ๋ฐ์ ์ ์ธ
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
ex) ์์ 1_sumFunc.kt
- ์์ ํจ์(Pure Function)
: ๋ถ์์ฉ์ด ์๋ ํจ์๋ก, ๊ฐ์ด ์์ธก ๊ฐ๋ฅํ์ฌ ๊ฒฐ์ ์ (deterministic)์ด๋ค.
--> ๋์ผํ ์ ๋ ฅ ์ธ์์ ๋ํด์๋ ํญ์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ฑฐ๋ ์ถ๋ ฅํ๊ธฐ ๋๋ฌธ
: ์์ ํจ์๊ฐ ๋๊ธฐ ์ํ ์กฐ๊ฑด
๊ฐ์ ์ธ์์ ๋ํ์ฌ ํญ์ ๊ฐ์ ๊ฐ ๋ฐํ | ํจ์ ์ธ๋ถ์ ์ํ๋ฅผ ๋ณํ์ํค์ง ์์์ผ ํจ |
ex) ์์ ํจ์์ ์
fun sum(a: Int, b: Int): Int
{
return a + b //๋์ผํ ์ธ์์ธ a, b๋ฅผ ์
๋ ฅ๋ฐ์ ํญ์ a + b๊ฐ์ ์ถ๋ ฅ
}
- ๋๋ค์(Lamda Expression)
: ๋๋ค ๋์๋ก๋ถํฐ ์ ๋ํ์์ผ๋ฉฐ, ์ต๋ช ํจ์์ ํ๋์ ํํ์ด๋ค. ์ด๋ฆ ์์ด๋ ์ฌ์ฉ ๋ฐ ์คํ์ด ๊ฐ๋ฅํ๋ค๋ ํน์ง์ด ์๋ค.
{ x, y -> x + y } //๋๋ค์์ ์์ (์ด๋ฆ์ด ์๋ ํจ์ ํํ)
: ๋๋ค์์ ์ด์ฉ
--> ๋๋ค์์ ๊ณ ์ฐจ ํจ์์์ ์ธ์๋ก ๋๊ธฐ๊ฑฐ๋ ๊ฒฐ๊ณผ๊ฐ์ผ๋ก ๋ฐํ ๋ฑ์ ์์ ์ ๊ฐ๋ฅํ๊ฒ ํ๋ค.
--> ์๋์ฒ๋ผ ๋ณ์์ ๋๋ค์์ ์ ์ฉํ์ฌ ์ฌ์ฉํจ
fun main()
{
var result: Int
val multi = {x: Int, y: Int -> x * y }
result = multi(10, 20)
println(result)
}
ex) ์ผ๋ฐ์ ์ธ ๋ฉ์๋ ํ์์ ๋๋ค์์ผ๋ก ํํํ๊ธฐ
fun addNumber (n1: Int, n2: Int): Int
{
return n1 + n2
}
//๋๋ค์ ํํ
val addNumber = { n1: Int, n2: Int -> n1 + n2 }
: ๋๋ค์์ ํน์ง
1. ๋๋ค์์ ์ค๊ดํธ๋ก ๊ฐ์ธ๋ฉฐ, fun ์์ฝ์ด๋ฅผ ์ฌ์ฉ X |
2. ์ค๊ดํธ {} ์ '->'์ ์ข์ธก์ ํ๋ผ๋ฏธํฐ๋ฅผ, ์ฐ์ธก์ ํจ์์ ๋ด์ฉ์ ์๋ฏธ |
3. ํ์ดํ์ ์ค๋ฅธ์ชฝ ๋ฌธ์ฅ์ด ์ฌ๋ฌ ๊ฐ์ผ ๊ฒฝ์ฐ ์ธ๋ฏธ์ฝ๋ก (;)์ ์ฌ์ฉํ์ฌ ๊ตฌ๋ถ |
4. ๋ด์ฉ ์ค ๋ง์ง๋ง ๋ฌธ์ฅ์ ๋ฐํ ๊ฐ์ ์๋ฏธ |
- ๊ณ ์ฐจ ํจ์(high-order function)
: ์ผ๋ฐ ํจ์๋ฅผ ์ธ์๋ ๋ฐํ๊ฐ์ผ๋ก ์ฌ์ฉํ๋ ํจ์
# Kotlin ๊ธฐ๋ณธ ๋ฌธ๋ฒ_๋ฉ์๋์ ์ ์ญ ๋ณ์, ์ง์ญ ๋ณ์
- ๋ฉ์๋
: ๊ธฐ๋ณธ ๋ฉ์๋์ธ main() ํจ์ ์ธ์ ์ฌ์ฉ์๊ฐ ์์๋ก ๋ฉ์๋๋ฅผ ์ถ๊ฐ๋ก ์์ฑ ๊ฐ๋ฅ
: ๋ฉ์๋ ํธ์ถ ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๋๊ธธ ์ ์์
: ๋ฉ์๋์์ ์ฌ์ฉ๋ ๊ฒฐ๊ณผ๋ฅผ return ๋ฌธ์ ์ด์ฉํ์ฌ ๋ฐํ ๊ฐ๋ฅ
- ๋ณ์
์ ์ญ ๋ณ์(global variable) | ์ง์ญ ๋ณ์(local variable) |
๋ชจ๋ ๋ฉ์๋์์ ์ฌ์ฉ | ๋ฉ์๋ ๋ด๋ถ์์๋ง ์ฌ์ฉ |
ex) ์์ 1_exam04.kt