์ฝํ๋ฆฐ ์ธ์ด ์๊ฐ
์ฝํ๋ฆฐ์ ๋ฑ์ฅ ๋ฐฐ๊ฒฝ
- ์ฝํ๋ฆฐ์ด๋? JetBrains์์ ์คํ ์์ค ๊ทธ๋ฃน์ ๋ง๋ค์ด ๊ฐ๋ฐํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด.
- ์๋ฐ์ ๊ฐ์๋จธ์ ์ธ JVM์ ๊ธฐ๋ฐ์ ๋ ์ธ์ด.
์ฝํ๋ฆฐ์ ์ฅ์
1) ํํ๋ ฅ๊ณผ ๊ฐ๊ฒฐํจ(expressive and concise) : ์๋ฐ๋ณด๋ค ๊ฐ๊ฒฐํ ๊ตฌ๋ฌธ
2) ์์ ํ ์ฝ๋(safer code) : ์ฝํ๋ฆฐ์ Null safety๋ฅผ ์ง์
-> ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋จ์์ ๊ฐ์ฒด๋ ๋ ์ํ์ผ ์ ์์ผ๋ฉฐ, ์ด ๋ NullPointerException์ด ๋ฐ์ํ ์ ์๋๋ฐ
์ฝํ๋ฆฐ์์๋ ๋ณ์๋ฅผ nullable๊ณผ not null๋ก ๊ตฌ๋ถํด์ ์ ์ธํ๊ธฐ ๋๋ฌธ์ null๊ณผ ๊ด๋ จ๋ ์ฌ๋ฌ ๋ถ๋ถ์ ์ปดํ์ผ๋ฌ๊ฐ ํด๊ฒฐ
3) ์ํธ ์ด์ฉ์ฑ(interoperable) : ์ฝํ๋ฆฐ์ ์๋ฐ์ 100% ํธํ. ์๋ฐ์ ์ฝํ๋ฆฐ ํผ์ฉ ๊ฐ๋ฅ
4) ๊ตฌ์กฐํ ๋์์ฑ(structured concurrency) : ์ฝ๋ฃจํดcorutines์ ์ด์ฉํ๋ฉด ๋น๋๊ธฐ ํ๋ก๊ทธ๋จ์ ๊ฐ์ํ ๊ฐ๋ฅ
- ๋คํธ์ํฌ ์ฐ๋์ด๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ฐฑ์ ๋ฑ์ ์ฌ์ฉ
์ฝํ๋ฆฐ ํ์ผ ๊ตฌ์ฑ
- ํ์ฅ์๋ '.kt'
- package ์ด๋ฆ์ kt ํ์ผ์ ์์น์ ์๊ด์๋ ๋ณ๋์ ์ด๋ฆ์ผ๋ก๋ ์ ์ธํ ์ ์๋ค. ์ด ๊ฒฝ์ฐ, ์ปดํ์ผ๋ ํด๋์ค ํ์ผ์ ๋ณ๋์ ์ด๋ฆ ํด๋์ ์์ฑ๋๋ค.
- ์ฝํ๋ฆฐ ํ์ผ๋ช ์ ํด๋์ค ํ์ผ๋ช ๊ณผ ๋ค๋ฅด๊ฒ ์ ์ธํ ์ ์๋ค.
- ๋ณ์์ ํจ์๋ ํด๋์ค ์๋ฟ๋ง ์๋๋ผ ํด๋์ค ๋ฐ์๋ ์ ์ธํ ์ ์๋ค.(ํ์ผ๋ช +Kt๋ก ์ปดํ์ผ)
- ๊ฐ์ package ์์ ์ ์ธ๋ ํ์ผ์ import ์์ด ์ฌ์ฉํ ์ ์๋ค.
๋ณ์์ ํจ์
๋ณ์ ์ ์ธ
1) val(value) : ์ด๊น๊ฐ์ด ํ ๋น๋๋ฉด ๋ฐ๊ฟ ์ ์๋ ๋ณ์
2) var(variable) : ์ด๊น๊ฐ์ด ํ ๋น๋ ํ์๋ ๊ฐ์ ๋ฐ๊ฟ ์ ์๋ ๋ณ์๋ฅผ ์ ์ธ
val(var) ๋ณ์๋ช
: ํ์
= ๊ฐ
val data1 = 10
ํ์ ์ง์ ๊ณผ ํ์ ์ถ๋ก
๋ณ์๋ช ๋ค์๋ ์ฝ๋ก (:)์ ์ถ๊ฐํด ํ์ ๋ช ์ ๊ฐ๋ฅ.
๋์ ํ๋ ๊ฐ์ ๋ฐ๋ผ ํ์ ์ ์ถ ๊ฐ๋ฅํ๋ค๋ฉด ์๋ต ๊ฐ๋ฅ.
var data1: Int = 10
์ด๊น๊ฐ ํ ๋น
- ์ต์์์ ์ ์ธํ ๋ณ์/ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์ : ์ ์ธ๊ณผ ๋์์ ์ด๊น๊ฐ ํ ๋น ํ์
- ํจ์ ๋ด๋ถ์ ์ ์ธํ ๋ณ์ : ์ ์ธ๊ณผ ๋์์ ์ด๊น๊ฐ ํ ๋นํ ํ์ X
์ด๊น๊ฐ ๋ฏธ๋ฃจ๊ธฐ
๋ณ์๋ฅผ ์ ์ธํ ๋ ์ด๊น๊ฐ์ ํ ๋นํ ์ ์๋ ๊ฒฝ์ฐ - ์ปดํ์ผ๋ฌ์๊ฒ ์๋ฆผ ํ์
1) lateinit : ์ดํ์ ์ด๊น๊ฐ์ ํ ๋นํ ๊ฒ์์ ๋ช ์์ ์ผ๋ก ์ ์ธ
- ์ ์ธ๊ณผ ๋์์ ์ด๊น๊ฐ์ ํ ๋นํ์ง ์์๋ ๋์ง๋ง ๋ชจ๋ ์ ํ์ ๋ณ์ ์ ์ธ์๋ ์ฌ์ฉ ๋ถ๊ฐ
- var ํค์๋๋ก ์ ์ธํ ๋ณ์์๋ง ์ฌ์ฉ ๊ฐ๋ฅ
- Int, Long, Short, Double, Float, Boolean, Byte ํ์ ์๋ ์ฌ์ฉ ๋ถ๊ฐ
lateinit var data: String
2) lazy : ์์ค์์ ๋ณ์๊ฐ ์ต์ด๋ก ์ด์ฉ๋๋ ์๊ฐ ์ค๊ดํธ๋ก ๋ฌถ์ ๋ถ๋ถ ์๋ ์คํ๋์ด ๊ทธ ๊ฒฐ๊ด๊ฐ์ด ๋ณ์ ์ด๊น๊ฐ์ผ๋ก ํ ๋น
- ๋ณ์ ์ ์ธ๋ฌธ ๋ค์ by lazy { } ํ์์ผ๋ก ์ ์ธ
val data: Int by lazy{
println("In lazy....")
10
}
๋ฐ์ดํฐ ํ์
์ฝํ๋ฆฐ์ ๋ชจ๋ ๋ณ์๋ ๊ฐ์ฒด = ์ฝํ๋ฆฐ์ ๋ชจ๋ ํ์
์ ๊ฐ์ฒด ํ์
(๊ธฐ์ด ๋ฐ์ดํฐ ํ์
ํด๋์ค) > ๋๋ฌธ์๋ก ์์
- null๊ฐ ๋์
- ๊ฐ์ฒด์ ๋ฉ์๋ ํธ์ถ ๊ฐ๋ฅ
var data1: Int = 10
var data2: Int? null // null ๋์
๊ฐ๋ฅ
data1 = data1.plus(10) // ๊ฐ์ฒด์ ๋ฉ์๋ ์ด์ฉ ๊ฐ๋ฅ
1. ๊ธฐ์ด ํ์ ๊ฐ์ฒด : Int, Short, Long / Double, Float / Byte / Boolean
- ๊ธฐ์ด ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ํํํ๋ ํ์
2. ๋ฌธ์์ ๋ฌธ์์ด : Char, String
1) Char : ๋ฌธ์๋ฅผ ํํํ๋ ํ์ . ์์ ๋ฐ์ดํ๋ก ํ์. Number ํ์ ์ผ๋ก ํํ ๋ถ๊ฐ
2) String : ๋ฌธ์์ด์ ํํํ๋ ํ์
- ํฐ๋ฐ์ดํ(")๋ก ํํํ ๋ฌธ์์ด : enter, tab ์ ์งํ๋ ค๋ฉด \๋ก ์์ํ๋ ์ด์ค์ผ์ดํ ์ํ์ค ํ์ ex) \n, \t
- ์ผ์ค๋ฐ์ดํ(""")๋ก ํํํ ๋๋ ํค๋ณด๋๋ก ์ ๋ ฅํ ์ค๋ฐ๊ฟ์ด๋ ๋ค์ฌ์ฐ๊ธฐ ๋ฑ์ด ๋ฐ์ดํฐ์ ๊ทธ๋๋ก ๋ฐ์
-> ์ฌ์ฉ ์ ๋ซ๋ ๋ฐ์ดํ ๋ค์ .trimIndent() ์๋ ์ถ๊ฐ(๋ฌธ์์ด ์์ ๊ณต๋ฐฑ ์ ๊ฑฐ)
- $๋ฅผ ์ด์ฉํด ๋ณ์ซ๊ฐ ํ์
3. Any : ๋ชจ๋ ํ์ ๊ฐ๋ฅ
์ฝํ๋ฆฐ์์ ์ต์์ ํด๋์ค. ๋ชจ๋ ํ์ ์ ๋ฐ์ดํฐ ํ ๋น ๊ฐ๋ฅ
class User
var data1: Any = User()
4. Unit : ๋ฐํ๋ฌธ์ด ์๋ ํจ์
Unit ๊ฐ์ฒด๋ง ๋์ ๊ฐ๋ฅ. ํจ์์์ ๋ฐํ๋ฌธ์ด ์์์ ๋ช ์์ ์ผ๋ก ๋ํ๋ผ ๋ Unit ํ์ ์ฌ์ฉ
๋ฐํ ํ์ ์ ์๋ตํ๋ฉด ์๋์ผ๋ก Unit ์ ์ฉ
fun some(): Unit {}
5. Noting : null์ด๋ ์์ธ๋ฅผ ๋ฐํํ๋ ํจ์
null๋ง ๋์ ๊ฐ๋ฅ.(๋ฐ์ดํฐ๋ก์์ ์๋ฏธ X)
val data1: Nothing? = null
fun some1(): Nothing? { return null } // null ๋ฐํ ํจ์
fun some2(): Nothing { throw Exception } // ์์ธ๋ฅผ ๋์ง๋ ํจ์
6. ๋ ํ์ฉ๊ณผ ๋ถํ์ฉ
๋ ํ์ฉ : ํ์ ๋ค์ ๋ฌผ์ํ๋ฅผ ์ถ๊ธฐ
๋ ๋ถํ์ฉ : ๋ฌผ์ํ๋ฅผ ์ถ๊ฐํ์ง ์์
ํจ์ ์ ์ธํ๊ธฐ
- fun ํค์๋ ์ด์ฉ
- ํจ์์ ๋งค๊ฐ๋ณ์์๋ val์ด ์๋์ผ๋ก ์ ์ฉ.
์ปฌ๋ ์ ํ์ : ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํํํ๋ ๋ฐฉ๋ฒ
1. Array : ๋ฐฐ์ดํํ
- ๋ฐฐ์ด์ ํฌ๊ธฐ, ์ด๊น๊ฐ ์ง์ / ๋ฐฐ์ด์ ํ์ ์ ์ ๋ค๋ฆญ(์ด์ฉํ๋ ๊ณณ์์ ํ์ ์ง์ )
<init>(size: Int, init: (Int) -> T) // Array ํด๋์ค์ ์์ฑ์
2. ๊ธฐ์ด ํ์ ์ ๋ฐฐ์ด
- BooleanArray, ByteArray, CharArray, DoubleArray, FloatArray, IntArray, LongArray, ShortArray
val data1: IntArray = IntArray(3, {0, })
- arrayOf() : ๋ฐฐ์ด์ ์ ์ธํ ๋ ๊ฐ ํ ๋น -> ๊ธฐ์ด ํ์ ์ ๋์์ผ๋ก ํ๋ ___ArrayOf() ํจ์ ์ ๊ณต
val data1 = arrayOf<Int>(10, 20, 30)
3. List, Set, Map(์ปฌ๋ ์ ํ์ ํด๋์ค)
Collection ์ธํฐํ์ด์ค๋ฅผ ํ์ ์ผ๋ก ํํํ ํด๋์ค
์์ | ์ค๋ณต | |
List | O | O |
Set | X | X |
Map | ํค์ ๊ฐ์ผ๋ก ๊ตฌ์ฑ | X(ํค์ ์ค๋ณต) |
1) ๊ฐ๋ณ ํด๋์ค : ์ด๊น๊ฐ์ ๋์ ํ ์ดํ์๋ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ๋ณ๊ฒฝ ๊ฐ๋ฅ -> size(), get() + add(), set()
2) ๋ถ๋ณ ํด๋์ค : ์ด๊ธฐ์ ๋ฐ์ดํฐ๋ฅผ ๋์ ํ๋ฉด ๋ ์ด์ ๋ณ๊ฒฝํ ์ ์๋ ํ์ -> size(), get()
๊ตฌ๋ถ | ํ์ | ํจ์ | ํน์ง |
List | List | listOf() | ๋ถ๋ณ |
MutableList | MutableListOf() | ๊ฐ๋ณ | |
Set | Set | setOf() | ๋ถ๋ณ |
MutableSet | MutableSetOf() | ๊ฐ๋ณ | |
Map | Map | mapOf() | ๋ถ๋ณ |
MutableMap | mutableMapOf() | ๊ฐ๋ณ |
- map : Pair ๊ฐ์ฒด๋ฅผ ์ด์ฉํ๊ฑฐ๋ 'ํค to ๊ฐ' ํํ๋ก ์ด์ฉ
var map = mapOf<String, String>(Pair("one", "hello"), "two" to "world")
์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ
1. ์กฐ๊ฑด๋ฌธ if-else if-else
- ํํ์์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ(๊ฒฐ๊ด๊ฐ์ ๋ฐํํ๋ ๊ณ์ฐ์) - ์ด ๋ else ์๋ต ๋ถ๊ฐ๋ฅ
var result = if (data>0){
true // ์ฐธ์ผ ๋ ๋ฐํ๊ฐ
} else {
false // ๊ฑฐ์ง์ผ ๋ ๋ฐํ๊ฐ
}
2. ์กฐ๊ฑด๋ฌธ when
- ์กฐ๊ฑด์ผ๋ก ์ ์๊ฐ ์๋ ๋ค๋ฅธ ํ์ ์ ๋ฐ์ดํฐ ์ง์ ๊ฐ๋ฅ
- is : ํ์ ์ ํ์ธํ๋ ์ฐ์ฐ์
- in : ๋ฒ์ ์ง์ ์ฐ์ฐ์(์์ชฝ ํฌํจ)
when (data) {
is String => println("data is String")
20, 30 => println("data is 20 or 30")
in 1..10 -> println("data is 1...10")
else -> println("data is not valid")
}
- ๋ฐ์ดํฐ๋ฅผ ๋ช ์ํ์ง ์๊ณ ์กฐ๊ฑด๋ง ๋ช ์ ๊ฐ๋ฅ
- ํํ์์ผ๋ก๋ ์ฌ์ฉ ๊ฐ๋ฅ
var result = when {
data <= 0 -> "data is <= 0"
data > 100 -> "data is > 100"
else -> "data is valid"
}
3. ๋ฐ๋ณต๋ฌธ for, while
1) for๋ฌธ
- ์ฃผ๋ก ๋ฒ์ ์ฐ์ฐ์์ธ in์ ์ฌ์ฉ(์์ชฝ ํฌํจ)
for (i in 1..10) {} // 1๋ถํฐ 10๊น์ง 1์ฉ ์ฆ๊ฐ
for (i in 1 until 10) {} // 1๋ถํฐ 9๊น์ง 1์ฉ ์ฆ๊ฐ(10์ ๋ฏธํฌํจ)
for (i in 2..10 step 2) {} // 2๋ถํฐ 10๊น์ง 2์ฉ ์ฆ๊ฐ
for (i in 10 downTo 1) {} // 10๋ถํฐ 1๊น์ง 1์ฉ ๊ฐ์
- indices : ์ปฌ๋ ์ ํ์ ์ ์ธ๋ฑ์ค ๊ฐ
- withIndex( ) : ์ธ๋ฑ์ค์ ์ค์ ๋ฐ์ดํฐ๋ฅผ ํจ๊ป ๊ฐ์ ธ์จ๋ค
for ((index, value) in data.withIndex())
2) while๋ฌธ
'Android' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Chap 6] ๋ทฐ๋ฅผ ์ด์ฉํ ํ๋ฉด ๊ตฌ์ฑ (0) | 2021.11.30 |
---|---|
[Chap 5] ์ฝํ๋ฆฐ์ ์ ์ฉํ ๊ธฐ๋ฒ (0) | 2021.11.23 |
[Chap 4] ์ฝํ๋ฆฐ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ (0) | 2021.11.20 |
[Chap 2] ์๋๋ก์ด๋ ์ฑ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ (0) | 2021.11.17 |
[Chap 1] ์๋๋ก์ด๋ ์คํ๋์ค ์ค์น ๊ณผ์ ์์ ์ฃผ์ ์ฃผ์ (0) | 2021.11.09 |
๋๊ธ