์ฝํ๋ฆฐ ์ธ ์ก์ ์ฑ ์ผ๋ก ์คํฐ๋๋ฅผ ํ๊ฒ ๋๋๋ฐ, ๋ด๊ฐ ์ดํดํ ๊ฒ์ ๊ธฐ๋ฐ์ผ๋ก ์ ๊ธฐ๋กํด๋ ๊ณํ์ด๋ค.
๊ฐ์
์ฝํ๋ฆฐ์ ์ ์ ํ์ ์ง์ ์ธ์ด๋ค
์ ์ ํ์ (statically typed) ์ง์ ์ด๋ผ๋ ๋ง์ ๋ชจ๋ ๊ตฌ์ฑ์์์ ํ์ ์ ์ปดํ์ผ ๋ ์ ์ ์๊ณ , ๊ฐ์ฒด์ ํ๋/๋ฉ์๋๋ฅผ ์ฌ์ฉ ์ ์ปดํ์ผ๋ฌ๊ฐ ํ์ ์ ๊ฒ์ฆํ๋ค๋ ๋ป์ด๋ค. ๋์ ํ์ ์ ํ์ ๊ณผ ๋ฌด๊ดํ๊ฒ ๋ชจ๋ ๊ฐ์ ๋ณ์์ ๋ฃ์ ์ ์๊ณ , ๊ฒ์ฆ์์ ์ด ์คํ์์ ์ด๋ค. Groovy๊ฐ ๋ํ์ ์ธ๋ฐ, ๊ฐ๊ฒฐํ ์ฝ๋๋ ํ์คํ ์ฅ์ ์ด์ง๋ง ์ปดํ์ผ ์ ๊ฑธ๋ฌ๋ด์ง ๋ชปํ๋ ์ค๋ฅ๊ฐ ์คํ์์ ์ ๋ฐ์ํ๊ธฐ ๋๋ฌธ์ ๊ฐ๊ฐ ์ฅ๋จ์ ์ด ์๋ค.
์ ์ ํ์ ์ง์ ์ธ์ด์ ์ฅ์ ์ ์ฑ๋ฅ, ์ ๋ขฐ์ฑ(์ปดํ์ผ๋ฌ ๊ฒ์ฆ), ์ ์ง๋ณด์์ฑ, ๋๊ตฌ ์ง์ ๋ฑ์ด ์๋ค.
์ฝํ๋ฆฐ์ ์๋ฐ์ ๊ฐ์ ์ ์ ํ์ ์ง์ ์ธ์ด์ง๋ง, ์ปดํ์ผ๋ฌ๊ฐ ๋ฌธ๋งฅ์ผ๋ก ํ์ ์ ์ถ๋ก ํ๋ค. ๋ฐ๋ผ์ ํ์ ๋ช ์๊ฐ ๋ฐ๋ก ํ์ํ์ง ์์ง๋ง ์ ์ง ๋ณด์์ ๊ฐ๋ ์ฑ์ ์ํด ๋ช ์๋ฅผ ํด ์ฃผ๋๊ฒ ๋ ์ข์ ๋ฐฉํฅ์ด๋ค.
๋ง์ง๋ง์ผ๋ก ์ฝํ๋ฆฐ์ nullable type์ ์ง์ํ๊ธฐ ๋๋ฌธ์ ์ปดํ์ผ ์ null ๊ฒ์ฌ๋ฅผ ๊ฑฐ์น ์ ์๋ค. ๋ function type์ ์ง์ํ๊ธฐ ๋๋ฌธ์ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์ง์ํ๋ค. ์๋๋ก์ด๋ ์ฑ ๊ฐ๋ฐ์์๋ ์ด ์ฅ์ ์ ์ ํจํ๋ฐ, null์ ์ถ์ ํ๊ธฐ ๋๋ฌธ์ NPE(NullPointerException)์ ๋น๋๋ฅผ ํ ์ค์ผ ์ ์๊ฒ ๋๋ค.
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ
์ฒ์ ์ ํ์ ๋ ๊ต์ฅํ ๋ํด ํ๋๋ฐ, ํฌ๊ฒ 3๊ฐ์ง ํน์ง์ด ์๋ค.
- ํจ์๋ ์ผ๊ธ์๋ฏผ(์ผ๋ฐ ๊ฐ์ฒ๋ผ ์ฌ์ฉ๊ฐ๋ฅํ๋ค. ์ฌ์ง์ด ๋ฐํ๊ฐ์ผ๋ก ํจ์๋ฅผ ์ธ ์ ์๋ค.)
- ๋ถ๋ณ์ฑ
- side effect ์์(์์ ํจ์๋ฅผ ์ฌ์ฉ)
์ด๋ฐ ํน์ง์ ๊ฐ๊ฒฐ์ฑ์ ์ด๋ ค์ค ์ค๋ณต์ ์ค์ฌ์ฃผ๊ณ , ๋๊ธฐํ ๊ฑฑ์ ์ด ์์ด์ ๋ค์ค ์ค๋ ๋์์ ์ฌ์ฉ์ ์์ ํ๋ค๋ ์ ์ด๋ค. ๋ ์์ํจ์๋ฅผ ์ฌ์ฉํ๋ค๋ ์ ์ ํ ์คํธํ๊ธฐ ํธํ๋ค๋ ์ฅ์ ๋ ์๋ค.
์ฝํ๋ฆฐ ์ฒ ํ
์ค์ฉ์ฑ, ๊ฐ๊ฒฐ์ฑ, ์์ ์ฑ, ์ํธ์ด์ฉ์ฑ์ด ์๋๋ฐ, ๊ฐ ํญ๋ชฉ์ ๊ฐ๋จํ ์ ๋ฆฌํด๋ดค๋ค.
์ค์ฉ์ฑ:
์ด๋ฏธ ๋ค๋ฅธ ์ธ์ด๊ฐ ๊ฒ์ฆํ ํด๋ฒ๊ณผ ๊ธฐ๋ฅ๋ค์ ๋ต์ตํ๊ธฐ ๋๋ฌธ์ ์ฝํ๋ฆฐ์ ๋ฐฐ์ฐ๋๋ฐ ์๊ณ ๊ฐ ์ค๊ณ , IDE์ ์ข์ ๋๊ตฌ๊ฐ ๋ง๊ธฐ ๋๋ฌธ์(์ปดํ์ผ๋ ์๋ฐ ๋ฐ์ดํธ์ฝ๋ ์ฝ๊ธฐ์ ๊ฐ์) ์ค์ฉ์ ์ด๋ผ๊ณ ํ ์ ์๋ค.
๊ฐ๊ฒฐ์ฑ:
๋ณด์ผ๋ฌ ํ๋ ์ดํธ๋ฅผ ์๋ฐ์ ๋นํด ๋ง์ด ์ค์๋ค. getter, setter๋ ๋ฌผ๋ก ์ด๊ณ data class์ ๊ฐ์ ํน์ ํด๋์ค, ๋ค์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํด ์ฝ๋์ ๊ฐ๊ฒฐํจ์ ์ ์งํ๋ค.
์์ ์ฑ:
์ฐ์ ์ด๋์ ๋ ์์ ์ฑ์ด JVM์ ๋ฐ๋ฅด๊ธฐ๋๋ฌธ์ ์ ์ฆ๋์ด์๊ณ , ์ฌ๊ธฐ์ NPE์ ๋ํ ์์ ์ฑ์ด ์ถ๊ฐ๋ ๊ฒ์ด๋ค.
์ํธ ์ด์ฉ์ฑ:
์๋ฐ์ ๊ธฐ์กด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ทธ๋๋ก ๊ฐ์ ธ๋ค ์ฌ์ฉํ ์ ์๊ณ , ์๋ฐ์ ์ฝํ๋ฆฐ์ด ์์ธ ํ๋ก์ ํธ๋ฅผ ์ปดํ์ผํ๋๋ฐ ์๋ฌด๋ฐ ์ฅ์ ๊ฐ ๋์ง์๋๋ค.
์ปดํ์ผ ๊ณผ์
.kt๋ก ์ ์ฅ๋ ํ์ผ์ ์ปดํ์ผ๋ฌ๊ฐ ์ปดํ์ผ์ ๋ง์น๋ฉด .classํ์ผ์ ์์ฑํ๋ค. .classํ์ผ์ .jar๋ฅผ ํตํด ํจํค์ง๊ณผ์ ์ ๊ฑฐ์ณ ์ ํ๋ฆฌ์ผ์ด์ ์์ ์คํ๋๋ค. ์ฝํ๋ฆฐ ์ปดํ์ผ๋ฌ๋ฅผ ์ฌ์ฉํ ํ์ผ์ ์ฝํ๋ฆฐ ๋ฐํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์์กดํ๋ค. ๋ฐ๋ผ์ ์ฝํ๋ฆฐ์ผ๋ก ์ปดํ์ผ ๋ ์ฑ์ ๋ฐฐํฌํ ๋๋ ์ฝํ๋ฆฐ ๋ฐํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๊ฐ์ด ๋ฐฐํฌํด์ผ๋๋๋ฐ, gradle๊ณผ ๊ฐ์ ๋๊ตฌ๊ฐ ์ฑ ํจํค์ง ์์ ์ ์ฝํ๋ฆฐ ๋ฐํ์์ ํฌํจ์์ผ์ค๋ค. ์ด๋ฌ๋ฉด ์ฉ๋์ด ์ปค์ง๋ ๊ฒ ์๋๊น? ๋คํํ ์ฝํ๋ฆฐ ๋ฐํ์ ์์คํ ์ ์ฉ๋์ ์๊ธฐ ๋๋ฌธ์ ํฌํจ ์ ๊ณผ ํ์ ์ฉ๋ ์ฐจ์ด๊ฐ ํฌ๊ฒ ๋์ง ์๋๋ค.
์ฌ๊ธฐ์ ํ๋ฒ์ฏค์ ๊ถ๊ธํ ์๋ ์๋๋ฐ, ์ฝํ๋ฆฐ์ ํด๋์ค๋ฅผ ๋ง๋ค์ง ์๊ณ fun main(){ }์ผ๋ก ๋ฐ๋ก ์ฝ๋๋ฅผ ์คํํ ์ ์๋ค. ๊ทธ ์ด์ ๋ ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก ํด๋์ค๋ฅผ ๋ง๋ค๊ณ ์ง์ ์ ์ ๋ง๋ค์ด์ฃผ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ธฐ๋ณธ ์์๋ค
ํจ์
fun foo(param: Int): String{
return if(param>10) "BIG" else "SMALL"
}
ํ๋ผ๋ฏธํฐ๋ ์ด๋ฆ ๋ค์ ํ์ ์ ๋ช ์ํ๋ค.
์ฝํ๋ฆฐ์ if๋ ๋ฌธ(statement)์ด ์๋๋ผ ์(expression)์ด๋ค. ์ฆ ๊ฐ์ ๋ฐํ ํ ์ ์๊ณ ๋ค๋ฅธ ์์ ํ์ ์์๋ก ์ฐ์ฐ์ ๊ด์ฌํ ์ ์๋ค๋ ๊ฒ์ด๋ค. ์๋ฐ์ if๋ ๋ฌธ์ด์ง๋ง ์ฝํ๋ฆฐ์ if๋ ์์ด๋ค.
fun foo(param:Int) = if(param>10) "A" else "B"
ํจ์๊ฐ ์์ ๋ณธ๋ฌธ์ผ๋ก ๊ฐ์ง ์ ์๋๋ฐ, ์ด ๊ฒฝ์ฐ ๋ฐํํ์ ์ ์๋ตํ ์ ์๋ค.
๋ณ์
val, var๋ก ๋๋๋๋ฐ, val๋ก ์ ์ธํ ๋ณ์๋ immutableํ๊ณ , var๋ mutableํ๋ค. val๋ก ์ ์ธํ๋ ๊ฒ์ ์๋ฐ์ final ๋ณ์๋ก ์ดํดํ๋ฉด ๋๋ค. ๋ณ์๋ฅผ ์ด๊ธฐํ ํ ๋๋ ๋ณ์ ํ์ ์ด ํ์ ํ ์๋, ์์ ์๋ ์๋ค. ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ๋ฅผ ํ๋ค๋ฉด, ์ปดํ์ผ๋ฌ๊ฐ ํ์ ์ถ๋ก ์ด ๊ฐ๋ฅํ์ง๋ง, ์ด๊ธฐํ ์์ ์ด ์ ์ธ์์ ๋ณด๋ค ํ๋ผ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ํ์ ์ถ๋ก ์ ํ ์ ์๋ค. ๊ทธ๋์ ์ด๊ธฐํ๋ฅผ ๋์ค์ ํ ๊ฒฝ์ฐ ํ์ ๋ช ์๊ฐ ๊ผญ ํ์ํ๋ค.
์ฒ์ ์ฝํ๋ฆฐ์ ์ ํ ๋ ๋ค์๋ ์๋ฌธ์ธ๋ฐ
val arr = arrayListOf("a","b")
arr์ immutableํ๋ค. ๊ทธ๋ฌ๋ arr.add(“c”)๋ก ์กฐ์์ด ๊ฐ๋ฅํ๋ฐ, ์ ๊ทธ๋ด๊น.
val ์ฐธ์กฐ ์์ฒด๋ ๋ถ๋ณ์ด๋ค. ํ์ง๋ง ์ฐธ์กฐ๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ฒด์ ๋ด๋ถ ๊น์ง๋ val๊ฐ ๊ด์ฌํ์ง์๊ธฐ ๋๋ฌธ์ arr๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ฒด์ ๋ํ ์ฐ์ฐ์ด๋ผ๊ณ ๋ณด๋ฉด ๋๋ค.
๋ณ์๋ฅผ ๋ฌธ์์ด ์์์ ์ฌ์ฉํ๋ ค๋ฉด ์๋์ ๊ฐ์ด ํ๊ธฐํ๋ค. ์ด๋ฅผ ๋ฌธ์์ด ํ ํ๋ฆฟ์ด๋ผ๊ณ ํ๋ค.
print("Hello, $name")
print("Hello, ${name}")
์ด๋ฐ์์ผ๋ก $๋ฅผ ๋ถ์ฌ์ ์ฌ์ฉํ๋ฉด ๋๋๋ฐ, ์ค๊ดํธ๋ก ๋ฌถ์ด์ฃผ๋ ๊ฒ ์ข๋ค. ์ปดํ์ผ๋ฌ๊ฐ ๋ณ์์ ๋ฒ์๋ฅผ ์ ํํ๊ฒ ์ธ์ํ๊ฒ ํ๊ธฐ ์ํจ์ด๋ค. ๋ฉค๋ฒ ๋ณ์๋ฅผ ์ฌ์ฉํ๊ฑฐ๋, ํ๊ธ๊ณผ ์๋ฌธ๋ณ์๋ฅผ ๋ถ์ฌ ์ธ๋ ์ปดํ์ผ๋ฌ๊ฐ ์ค๋ฅ๋ฅผ ๋ด๊ฒ ๋๋ฏ๋ก ์ค๊ดํธ๋ก ๋ฌถ์ด์ ์ฌ์ฉํ๋ ๊ฒ ๊ถ์ฅ๋๋ค. ๋ณ์ ๋ฟ๋ง ์๋๋ผ ์๋ ์ค๊ดํธ์ ๋ฃ์ด ์ฌ์ฉํ ์ ์๋ค.
ํ๋กํผํฐ
์๋ฐ ํด๋์ค์์์ ํ๋์ ๊ฒํฐ, ์ธํฐ๋ฅผ ํ๋ฒ์ ๋ฌถ์ด์ ์ฝํ๋ฆฐ ํ๋กํผํฐ๊ฐ ํ์ํ๋ค. val๋ก ์ ์ธํ ํ๋กํผํฐ๋ ์ฝ๊ธฐ์ ์ฉ, var๋ก ์ ์ธํ ํ๋กํผํฐ๋ ์ฐ๊ธฐ์ ์ฉ์ด๋ค. ๋ฐ๋ผ์ val๋ ๊ฒํฐ๋ง ๊ฐ๊ณ , var๋ ๋๋ค ๊ฐ๋๋ค.
์ฝํ๋ฆฐ์ ํ๋กํผํฐ๋ ๊ธฐ๋ณธ์ผ๋ก getter๊ฐ ์์ง๋ง, ์ด๊ฑธ ์ปค์คํ ํ ์๋ ์๋๋ฐ ์ด ํ๋กํผํฐ๋ฅผ backing field๋ผ๊ณ ํ๋ฉฐ ํ๋กํผํฐ ๊ฐ์ ๊ทธ๋ ๊ทธ๋ ๊ณ์ฐํด์ ์ฌ์ฉํ๋ ์์ ์ด ํ์ํ ๋ ์ฌ์ฉํ ์ ์๋ค.
์ด๋ฐ ๊ฐ๋ง ๋ชจ์๋ ํด๋์ค๋ฅผ value object๋ผ๊ณ ํ๋๋ฐ, ์๋ฐ์์ getter์ setter๋ก ์ ์ฒ ๋ ์ฝ๋๊ฐ ์๋ค๋ฉด ์ฝํ๋ฆฐ์์๋ data class๋ผ๋ ๊ฐ๋ ฅํ ๋๊ตฌ๊ฐ ์๋ค.
val isSquare: Boolean
get(){
return h == w
}
get()์ ๋ถ์ฌ ์ ์ธํ๋ฉด ์ปค์คํ ์ ๊ทผ์๋ฅผ ๋ง๋ค ์ ์๊ฒ๋๋ค. ์ด ํ๋กํผํฐ๋ h์ w๊ฐ ๊ฐ์ผ๋ฉด true๋ฅผ ๋ฐํ ํ๋ ํ๋กํผํฐ๋ค.
enum๊ณผ when
enum์ ์ด๊ฑฐํ ํ์ ์ด๊ณ , when์ ๋ถ๊ธฐ ๋ฌธ๋ฒ์ด๋ค.
enum class Color{
RED, ORANGE, BLUE
}
enum class ๋ผ๋ ํค์๋๋ก enum๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค.
enum class ์์ ํ๋กํผํฐ์ ๋ฉ์๋๋ฅผ ์ ์ธ ํ ์ ์๋๋ฐ, ์ด๋ ์ฝํ๋ฆฐ์์ ์ ์ผํ๊ฒ ์ธ๋ฏธ์ฝ๋ก ์ด ์ฌ์ฉ๋๋ค. enum ์์๋ฅผ ์ ์ํ ๋, ์์ ๋ชฉ๋ก ๊ฐ์ฅ ๋์ ์ธ๋ฏธ์ฝ๋ก ์ผ๋ก ๊ตฌ๋ณ ์ง์ด์ค์ผ ๋ฉ์๋ ์ ์ ๋ถ๋ถ์ ์ธ์ํ๋ค.
์ด๋ ๊ฒ ๋ง๋ enum ๊ฐ์ฒด๋ when์์ ์ ์ฉํ๊ฒ ์ฐ์ธ๋ค.
when์ enum ํ์ ์ ๋ฃ์ผ๋ฉด, enum์ ์ ์๋ ๊ฐ์ผ๋ก๋ง when branch๋ฅผ ์์ฑํ๋ฉด ๋๋ค. ๋น ์ ธ์์ผ๋ฉด ์ปดํ์ผ์๋ฌ๊ฐ ์ผ์ด๋๊ณ , else๊ฐ ํ์์์ด ์ ์ง๋ณด์์ ์ข๋ค.
when ์ญ์ ๋ฐํ๊ฐ์ ๋์ถํ ์ ์๋ ์์ด๊ณ , switch์ ๋น์ทํ์ง๋ง ๋์ฑ ์ ์ฐํ๊ฒ ์๋ํ๋ค.
when(input){
a -> "A"
b,c -> "B"
1...5 -> "NUM"
else -> "O"
}
when์ break๋ฅผ ๋ฐ๋ก ์ ์ด์ค ํ์๊ฐ ์๊ณ , ๋น๊ต ๊ฐ์ ํ์ ์ด ๋ฌ๋ผ๋ ๋๊ณ , ๋ฒ์๋ก ๋น๊ตํ ์๋ ์๊ณ , ์ฌ๋ฌ๊ฐ ๊ฐ๊ณผ ๋งค์นํด ๋ณผ ์๋ ์๋ค. ์์ฃผ ์ ์ฐํ๋ค.
setOf()๋ฅผ ์ฌ์ฉํด ์งํฉ์ผ๋ก ๋น๊ต๋ ๊ฐ๋ฅํ๋ค. ์ด ๋ง์ ๊ฐ์ฒด ๋น๊ต๊ฐ ๋๋ค๋ ๋ง์ด๋ค. when์ ์ธ์๊ฐ ์์ ์๋ ์์ง๋ง, ํจ์ ๋ฐํ ๊ฐ์ผ๋ก ์ฌ์ฉ๋ ๋๋ ํจ์์ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ๋ก ์กฐ๊ฑด๋ถ๊ธฐ๋ก ๋๊ณ ๊ณผ ์ธ์ ์์ด๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
fun foo1(c1: Color, c2: Color) = when((c1 == "R")&&(c2 == "B") -> "P")
์ด๋ฐ์์ผ๋ก ์ฌ์ฉํ ์ ์๋ค. ์ฆ ๊ฐ ๋ถ๊ธฐ์ ์กฐ๊ฑด์ด booleanํ๋ณ์ด๋ฉด ๊ฐ๋ฅํ ๋ฐฉ์์ด๋ค.
๋ถ๊ธฐ์ ๋ธ๋ก์ ์ฌ์ฉํ๋ฉด ๋งจ ๋ง์ง๋ง ์ค์ return์ ๋ถ์ด์ง ์์๋ ๋ฐํ๊ฐ์ผ๋ก ์ธ์ํ๋ค.
ํ์ ์บ์คํ
์ค๋งํธ ์บ์คํธ๋ ์ปดํ์ผ๋ฌ๊ฐ ํ๋ก๊ทธ๋๋จธ ๋์ ์บ์คํ ์ ํด์ฃผ๋ ๊ฒ์ผ๋ก, is ๊ฒ์ฌ๋ฅผ ํตํด ํ์ ์ ์บ์คํ ํ๋ ๊ฒ์ด๋ค. ๊ฒ์ฌ๋ฅผ ๋ง์น ๋ณ์์ ํ์ ์ ๊ฒ์ฌ์ดํ ๊ณ์ ๊ฐ์ ํ์ ์ ๊ฐ๋๊ฒ์ผ๋ก ์ปดํ์ผ๋ฌ๊ฐ ์ธ์ํ๋ค. ๋ฐ๋ผ์ val๋ก ์ ์ธํด์ค์ผํ๋ค.
๋ช ์์ ์ธ ํ์ ์บ์คํ ์ as ํ์ ์ผ๋ก ํด์ฃผ๋ฉด ๋๋ค.
iteration
๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉ๋ฒ์ ์๋ ค์ฃผ๋ ์ ์ด๋ค
for(i in a..b)์ ๊ฐ์ ๋ฒ์ํํ๋ก ์ฌ์ฉํ ์ ์๊ณ , ๋ฐฐ์ด์ ๋์์ผ๋ก foreach๊ฐ์ด ๋๋ฆด ์๋ ์๋ค.
๋ฒ์ ์ง์ ์ ..๋ ํญ์ [ ] ์ด๋ค. a until b ๋ฅผ ์ฌ์ฉํ๋ฉด [ )๋ก ๋ ๊ฐ์ ํฌํจํ์ง ์๊ฒ ๋๋ค.
์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ์ปฌ๋ ์ ์ .withIndext()์ ์ธ๋ฑ์ค ๋ณ์๋ฅผ ๊ฐ์ด ๋ฃ์ด์ฃผ๋ฉด ๋๋๋ฐ
for((idx, i) in list.withIndex()
์ด๋ idx๊ฐ ์ธ๋ฑ์ค ๋ฒํธ๋ฅผ ๋ฐ๋ผ๊ฐ๋ค.
๋ฐ๋ณต๋ฌธ์์ ์ฌ์ฉ๋๋ in์ ์ฐ์ฐ์์ด๋ค. ์ด๋ค ๊ฐ์ด ํด๋น ๋ฒ์์ ์ํ๋์ง in์ ํตํด true/false๋ฅผ ์ ์ ์๋ค. when์์๋ ์ฌ์ฉ๋๋ ๊ฒ์ ๋ณธ ์ ์ด ์์ ๊ฒ์ด๋ค.
์์ธ์ฒ๋ฆฌ
์์ธ์ฒ๋ฆฌ์ ์ฌ์ฉ๋๋ try, throw ๋ฌธ ์ญ์ ์ฝํ๋ฆฐ์์๋ ์์ด๋ค.
val exc = try{
..
}catch(e: NumberFormatException){
// ์์ธ ๋ฐ์
}finally{
// ๋ง๋ฌด
}
์์ธ์ฒ๋ฆฌํ ๋๋ try~catch~finally๋ฅผ ์ฌ์ฉํ ์ ์๊ณ , ํจ์๊ฐ ๋ฐํ๊ฐ์ผ๋ก ์์ธ๋ฅผ ํฌํจํ ์๋ฌด๊ฐ ์๋ค. ์๋ฐ๋ก ์ฌ์ฉํ๋ค๋ณด๋ฉด throws IOException์ ์ฌ์ฉํ ๋๊ฐ ์๋๋ฐ ์ฝํ๋ฆฐ์๋ ๊ทธ ์์ ์ด ํ์์๋ค๋ ๋ป์ด๋ค.
"๋๊ธ, ๊ณต๊ฐ ๋ฒํผ ํ ๋ฒ์ฉ ๋๋ฅด๊ณ ๊ฐ์ฃผ์๋ฉด ํฐ ํ์ด ๋ฉ๋๋ค"
'๐๐๏ธ > ์ฝํ๋ฆฐ ์ธ ์ก์ ๐' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Kotlin in action(5) (0) | 2023.10.10 |
---|---|
Kotlin in action(4) (0) | 2023.10.10 |
Kotlin in action(3) (0) | 2023.10.10 |
Kotlin in action(2) (0) | 2023.10.10 |
Kotlin in action(9) (0) | 2023.10.10 |