코틀린 기본
### ✅ **안드로이드 개발할 때 Kotlin 문법을 얼마나 깊이 알아야 할까?**
**결론부터 말하면,** 안드로이드 개발을 시작하는 데 **Kotlin의 모든 고급 문법을 알 필요는 없어!**\
하지만 **기본 문법 + 실용적인 기능을 잘 이해하면 개발이 훨씬 편해지고 코드 품질도 좋아져.**
* * * * *
✅ **1\. 필수적으로 알아야 하는 Kotlin 문법 (안드로이드 개발 기본)**
----------------------------------------------
다음 문법은 **안드로이드 개발에서 자주 쓰이는 Kotlin 문법이니까 반드시 익혀야 해!**
### 🔹 **1️⃣ 변수 및 데이터 타입 (`val`, `var`, `nullable`)**
```
val name: String = "Alice" // 불변 변수
var age: Int = 25 // 가변 변수
var nullableText: String? = null // null 가능 변수
```
✔ **`val`(불변) vs `var`(가변) 차이**\
✔ **nullable 타입(`?`)과 null 체크 (`?.`, `!!`)** → `TextView`나 `Intent`에서 자주 사용
### ✅ **코틀린의 Nullable 타입(`?`)과 Null 체크 (`?.`, `!!`)**
코틀린에서는 **Nullable 타입과 Null 체크가 필수적**이야!
안드로이드 개발에서는 **`TextView`, `Intent`, `Bundle`, `SharedPreferences` 등에서 Null 처리가 자주 필요함.**
* * * * *
✅ **1\. Nullable 타입 (`?`)**
---------------------------
✔ 코틀린에서는 기본적으로 **null 값을 허용하지 않음.**
✔ `?`를 붙이면 **null을 허용하는 변수**가 됨.
```
var name: String = "Alice" // ❌ null 불가능
var nullableName: String? = null // ✅ null 가능
```
📌 **즉, `?`를 붙이면 변수가 null을 가질 수 있음!**
📌 **반대로 `?`가 없으면 null을 저장할 수 없음.**
* * * * *
✅ **2\. Null 체크 방법**
--------------------
### 🔹 **1️⃣ Safe Call (`?.`) → null이면 실행 안 함**
```
val length = nullableName?.length // null이면 실행 안 함
println(length) // null
```
✔ **`?.`를 사용하면 null일 경우 실행을 건너뜀.**
✔ `nullableName`이 `null`이면, `length`는 `null`이 됨.
✔ **안드로이드에서 `findViewById()` 결과가 null일 수도 있어서 자주 사용됨.**
```
val textView: TextView? = findViewById(R.id.textView)
textView?.text = "Hello" // textView가 null이면 아무 일도 안 일어남.
```
📌 **즉, `?.`는 Null을 안전하게 처리하는 연산자!**
* * * * *
### 🔹 **2️⃣ Elvis 연산자 (`?:`) → null이면 기본값 반환**
```
val nameLength = nullableName?.length ?: 0 // null이면 0 반환
println(nameLength) // 0
```
✔ **`?:`를 사용하면 null일 때 기본값을 설정할 수 있음.**
✔ 안드로이드에서 `Intent`나 `Bundle`에서 기본값을 설정할 때 자주 사용됨.
```
val intent = intent
val username = intent.getStringExtra("username") ?: "Guest"
```
📌 **즉, null일 경우 안전한 기본값을 반환하는 연산자!**
* * * * *
### 🔹 **3️⃣ Non-Null Assertion (`!!`) → null이면 강제 예외 발생**
```
val length = nullableName!!.length // null이면 앱 크래시 발생!
```
✔ `!!`는 null이 아님을 보장할 때 사용.
✔ **null이면 `NullPointerException`이 발생하므로 위험할 수 있음.**
✔ **보통 확실히 null이 아닐 때만 사용해야 함.**
```
val textView: TextView = findViewById(R.id.textView)!!
textView.text = "Hello"
```
📌 **즉, `!!`는 "절대 null이 아니다"라고 선언하는 것. 하지만 안전한 방법은 아님!** 🚨
* * * * *
✅ **3\. 안드로이드에서 `Nullable`이 필요한 상황**
------------------------------------
### 🔹 **1️⃣ `findViewById()` → View가 없을 수도 있음**
```
val textView: TextView? = findViewById(R.id.textView)
textView?.text = "Hello" // ✅ 안전
```
✔ `findViewById()`는 null을 반환할 수 있기 때문에 `?.`를 쓰는 게 안전함.
* * * * *
### 🔹 **2️⃣ Intent 값 받기 (`getStringExtra()`는 null을 반환할 수 있음)**
```
val username: String? = intent.getStringExtra("username")
println(username?.length) // ✅ 안전
println(username!!.length) // 🚨 null이면 앱 크래시 발생
println(username ?: "Guest") // ✅ null이면 기본값 "Guest" 반환
```
✔ **`Intent`에서 데이터를 가져올 때 `null`이 반환될 수 있으므로, `?:`를 사용하는 게 안전함!**
* * * * *
### 🔹 **3️⃣ `SharedPreferences` 값 가져오기**
```
val prefs = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE)
val savedName = prefs.getString("username", null) ?: "Unknown"
println(savedName) // "Unknown" (null이면 기본값 반환)
```
✔ **SharedPreferences에서 `null`이 올 수 있기 때문에 `?:`를 활용하면 안전함!**
* * * * *
✅ **4\. 정리**
------------
| **기능** | **설명** | **예제** |
| --- | --- | --- |
| **`?.` (Safe Call)** | null이면 실행 안 함 | `textView?.text = "Hello"` |
| **`?:` (Elvis 연산자)** | null이면 기본값 반환 | `val name = intent.getStringExtra("name") ?: "Guest"` |
| **`!!` (Non-Null Assertion)** | null이면 예외 발생 | `val textView: TextView = findViewById(R.id.textView)!!` |
📌 **즉, 안드로이드 개발에서는 `?.`와 `?:`를 잘 활용하면 NullPointerException을 피할 수 있어!** 🚀
* * * * *
### 🔹 **2️⃣ 조건문 (`if`, `when`)**
```
val result = if (age > 18) "Adult" else "Minor"
when (age) {
18 -> println("You're 18!")
in 19..30 -> println("Young adult")
else -> println("Other")
}
```
✔ **`when`문은 `switch`보다 강력해서 안드로이드 코드에서 자주 사용됨!**
* * * * *
### 🔹 **3️⃣ 함수 (`fun`, `default arguments`)**
```
fun greet(name: String = "Guest") {
println("Hello, $name!")
}
greet() // "Hello, Guest!"
greet("Alice") // "Hello, Alice!"
```
✔ **기본값을 가진 매개변수 (`name: String = "Guest"`)가 매우 유용함!**\
✔ **UI 이벤트 처리할 때 자주 쓰임**
* * * * *
### 🔹 **4️⃣ 확장 함수 (자주 활용됨)**
```
fun String.addPrefix(): String {
return "Prefix_$this"
}
println("Text".addPrefix()) // "Prefix_Text"
```
✔ **기존 클래스를 수정하지 않고 기능을 추가할 때 활용!**\
✔ **예: `TextView`의 텍스트 설정을 더 쉽게 만들기**
```
fun TextView.setCustomText(text: String) {
this.text = "Custom: $text"
}
```
✔ **이제 `textView.setCustomText("Hello")`처럼 쉽게 사용 가능!**
* * * * *
### 🔹 **5️⃣ 고차 함수 & 람다 (RecyclerView, 클릭 이벤트에서 필수!)**
```
fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
return op(a, b)
}
val result = operate(3, 4) { x, y -> x + y }
println(result) // 7
```
✔ **고차 함수(`op: (Int, Int) -> Int`)는 `setOnClickListener {}` 같은 이벤트 처리에서 자주 사용됨!**
```
button.setOnClickListener {
println("버튼 클릭됨!")
}
```
✔ **안드로이드에서 `setOnClickListener` 같은 콜백 함수에 람다가 자주 쓰이니까 익숙해지면 좋아.**
* * * * *
✅ **2\. 안드로이드 개발하면서 배우면 좋은 Kotlin 문법 (실용적인 기능)**
------------------------------------------------
### 🔹 **1️⃣ 데이터 클래스 (RecyclerView, API 응답 처리에서 필수!)**
```
data class User(val name: String, val age: Int)
val user = User("Alice", 25)
println(user) // User(name=Alice, age=25)
```
✔ **자동으로 `toString()`, `equals()`, `copy()` 생성됨!**\
✔ **안드로이드에서 데이터 모델로 많이 사용됨 (예: API 응답, SQLite 데이터 등)**
* * * * *
### 🔹 **2️⃣ 싱글톤 객체 (Application-wide 상태 관리)**
```
object UserManager {
var name: String = "Guest"
}
```
✔ **`object` 키워드는 안드로이드에서 전역 상태를 관리할 때 유용함!**
* * * * *
### 🔹 **3️⃣ 코루틴 (비동기 작업 필수!)**
```
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
delay(1000L)
println("비동기 실행 완료!")
}
println("메인 실행")
}
```
✔ **네트워크 요청, 데이터베이스 작업 등에 코루틴이 필수적!**\
✔ **안드로이드에서 `viewModelScope.launch {}` 같은 형태로 사용됨**
* * * * *
✅ **3\. 안드로이드에서 자주 안 쓰는 Kotlin 고급 문법**
--------------------------------------
안드로이드 개발에서 **필수적이지 않은 고급 문법**도 있어.\
✔ `reified`, `inline` 같은 **고급 제네릭 활용법**\
✔ `sealed class` (쓰긴 하지만 자주 쓰진 않음)\
✔ `delegation` (코틀린 고급 기능이지만 기본 개발에서는 잘 안 씀)\
✔ `operator overloading` (연산자 오버로딩, 일반적인 개발에서는 잘 안 씀)
📌 **즉, 안드로이드 개발을 시작하는 데는 Kotlin의 복잡한 고급 문법을 몰라도 됨!**
* * * * *
✅ **4\. 결론: 얼마나 깊이 알아야 할까?**
----------------------------
✔ **기본 문법 (`val`, `var`, `if`, `when`, `fun`, `List`, `Map`)은 반드시 알아야 함.**\
✔ **RecyclerView, 클릭 이벤트 등에서 자주 쓰이는 `람다`, `고차 함수`, `확장 함수`를 알아두면 좋음.**\
✔ **비동기 작업을 할 때 `Coroutine` 개념을 익혀두면 안드로이드 개발이 더 쉬워짐.**\
✔ **복잡한 Kotlin 문법(제네릭, 고급 람다, Delegation 등)은 안드로이드 개발에서는 필수가 아님.**
👉 **즉, 기본 문법 + 안드로이드에서 자주 쓰이는 기능 위주로 배우면 충분히 개발 가능!** 🚀\
👉 **고급 문법은 나중에 필요할 때 익히면 돼!** 🎯
---
### ✅ **XML 기반 UI vs Jetpack Compose 완전 다름?**
네, **완전히 다른 방식**이야!\
하지만 **최종적으로 같은 UI를 만드는 게 목표**이기 때문에,\
기본 개념을 이해하면 XML에서 Jetpack Compose로 넘어가기도 쉬워.
* * * * *
✅ **1\. XML 기반 UI vs Jetpack Compose 차이**
-----------------------------------------
| | **XML 기반 (전통적 안드로이드 UI)** | **Jetpack Compose (최신 UI 방식)** |
| --- | --- | --- |
| **UI 정의 방식** | XML 파일에서 UI 정의 | Kotlin 코드로 UI 정의 |
| **레이아웃 관리** | `LinearLayout`, `ConstraintLayout` 등 사용 | `Column`, `Row`, `Box` 등 사용 |
| **뷰 업데이트** | `findViewById()`, `ViewBinding` 필요 | 상태(State)를 변경하면 자동 업데이트 |
| **이벤트 처리** | `setOnClickListener` 등 사용 | `onClick {}` 같은 람다 함수 사용 |
| **복잡한 UI 관리** | Fragment, Adapter, RecyclerView 등 필요 | 코드 기반으로 UI 관리가 더 쉬움 |
| **성능** | XML 파싱 비용 있음 | 더 가볍고 빠름 (런타임에서 직접 UI 생성) |
| **코드량** | 비교적 많음 | 더 적은 코드로 같은 UI 구현 가능 |
* * * * *
✅ **2\. XML 기반 UI (전통적 안드로이드 개발 방식)**
-------------------------------------
**📌 XML에서 UI를 만들고 Kotlin에서 이를 조작하는 방식**\
✔ **오랫동안 사용된 전통적인 방식**\
✔ **안드로이드 초창기부터 사용되어 온 개발 방식**
### 🔹 **XML UI 예제 (`activity_main.xml`)**
```
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp">
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, Android!"
android:textSize="20sp"/>
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Click Me"/>
</LinearLayout>
```
### 🔹 **Kotlin에서 XML 조작 (`MainActivity.kt`)**
```
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main) // XML 연결
val textView = findViewById<TextView>(R.id.textView)
val button = findViewById<Button>(R.id.button)
button.setOnClickListener {
textView.text = "버튼이 클릭됨!"
}
}
}
```
✔ **XML에서 만든 UI 요소를 `findViewById()`로 가져와서 조작해야 함.**\
✔ **ViewBinding을 사용하면 `findViewById()`를 생략할 수 있음.**\
✔ **Fragment, Adapter, RecyclerView 등 다양한 요소를 함께 사용해야 함.**
📌 **기존 안드로이드 앱들은 대부분 이 방식을 사용하고 있음.**
* * * * *
✅ **3\. Jetpack Compose (최신 UI 개발 방식)**
---------------------------------------
✔ **XML 없이 모든 UI를 Kotlin 코드로 작성**\
✔ **State 기반 UI → 값이 변경되면 UI가 자동 업데이트됨**\
✔ **RecyclerView, Adapter가 필요 없음 → 훨씬 간결한 코드**
### 🔹 **Jetpack Compose UI 예제 (`MainActivity.kt`)**
```
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MyScreen()
}
}
}
@Composable
fun MyScreen() {
var text by remember { mutableStateOf("Hello, Android!") }
Column(
modifier = Modifier.fillMaxSize().padding(16.dp),
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(text = text, fontSize = 20.sp)
Button(onClick = { text = "버튼이 클릭됨!" }) {
Text("Click Me")
}
}
}
```
✔ **XML 없이 UI를 Kotlin 코드로 직접 정의**\
✔ **`mutableStateOf()`를 사용해 값이 바뀌면 자동으로 UI 업데이트**\
✔ **기존 `findViewById()`가 필요 없음!**
📌 **Compose는 XML을 완전히 대체할 수 있도록 설계된 최신 UI 프레임워크야!**
* * * * *
✅ **4\. XML 기반 vs Jetpack Compose 코드 비교**
-----------------------------------------
| | **XML 기반 UI** | **Jetpack Compose** |
| --- | --- | --- |
| **TextView 사용** | `<TextView android:text="Hello" />` | `Text(text = "Hello")` |
| **Button 클릭 이벤트** | `button.setOnClickListener {}` | `Button(onClick = { })` |
| **레이아웃 관리** | `<LinearLayout>` `<ConstraintLayout>` | `Column {}` `Row {}` |
| **상태 관리** | `findViewById()` + `setText()` | `var text by remember { mutableStateOf("Hello") }` |
📌 **Jetpack Compose는 기존 XML 방식보다 코드가 짧고 직관적이야.**\
📌 **RecyclerView, Adapter 없이 리스트를 쉽게 만들 수 있어.**
* * * * *
✅ **5\. Jetpack Compose가 완전히 XML을 대체할까?**
-----------------------------------------
✔ 현재는 **XML과 Compose가 공존하는 시기**\
✔ 하지만 구글은 **Jetpack Compose를 차세대 표준 UI로 밀고 있음**\
✔ **새 프로젝트라면 Jetpack Compose가 더 좋고, 기존 프로젝트 유지보수라면 XML이 필요할 수도 있음**
* * * * *
✅ **6\. 결론**
------------
✔ **XML 기반 UI와 Jetpack Compose는 완전히 다른 방식!**\
✔ **XML은 전통적인 UI 방식이지만, Jetpack Compose는 최신 UI 방식**\
✔ **Jetpack Compose는 코드가 간결하고 상태 관리를 쉽게 해줌**\
✔ **새로운 프로젝트라면 Jetpack Compose를 배우는 게 유리함!** 🚀
👉 **XML 기반 UI를 사용할 거면 기존 방식(`findViewById`, `ViewBinding`)을 익히면 되고,**\
👉 **Jetpack Compose를 사용할 거면 `@Composable`, `State`, `Column`, `Row` 같은 개념을 익히면 돼!**
맞아! 예전에 XML 기반으로 안드로이드 개발을 배웠다면, **기본 개념은 거의 같아**.\
**다만, 최근에는 `findViewById()` 대신 ViewBinding을 쓰거나, 코루틴으로 비동기 처리를 하는 등 최신 방식이 추가됐어.**
* * * * *
✅ **1\. XML 기반 UI, 예전과 거의 동일!**
-------------------------------
✔ **`LinearLayout`, `ConstraintLayout`, `RecyclerView` 등 그대로 사용 가능**\
✔ **XML로 UI 만들고, Kotlin 코드에서 조작하는 방식 유지**\
✔ **예전에는 `findViewById()`를 썼지만, 최근엔 `ViewBinding`을 많이 사용**
### 🔹 **예제 (기본 UI)**
```
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp">
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, Android!"
android:textSize="20sp"/>
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Click Me"/>
</LinearLayout>
```
📌 **이런 방식은 예전과 동일!**\
📌 **하지만 Kotlin에서는 `findViewById()` 대신 `ViewBinding`을 추천!**
* * * * *
✅ **2\. `findViewById()` 대신 `ViewBinding` 사용 (추천)**
---------------------------------------------------
예전에는 이렇게 `findViewById()`를 많이 썼지?
```
val textView = findViewById<TextView>(R.id.textView)
val button = findViewById<Button>(R.id.button)
```
✔ 하지만 최근엔 **`ViewBinding`을 써서 더 간결하게 처리 가능!**
### 🔹 **ViewBinding 설정 (최신 방식)**
1. **`build.gradle (Module: app)`에서 `viewBinding` 활성화**
```
android {
buildFeatures {
viewBinding = true
}
}
```
1. **ViewBinding 사용 예제**
```
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.button.setOnClickListener {
binding.textView.text = "버튼이 클릭됨!"
}
}
}
```
📌 **장점:**\
✔ `findViewById()` 없이 `binding.textView.text = "..."`처럼 직접 접근 가능\
✔ **코드가 더 간결해지고, Null Safety 보장**\
✔ **버그가 줄어듦 (잘못된 `id`를 사용할 가능성 ↓)**
* * * * *
✅ **3\. `AsyncTask` 대신 코루틴 (비동기 처리)**
-------------------------------------
✔ 예전에는 **`AsyncTask`** 를 사용했는데, 이제는 **`Coroutine`(코루틴)** 을 추천해!\
✔ **UI 업데이트를 쉽게 유지하면서 백그라운드 작업을 할 수 있음.**
### 🔹 **예전 방식 (`AsyncTask`)**
```
class MyTask : AsyncTask<Void, Void, String>() {
override fun doInBackground(vararg params: Void?): String {
Thread.sleep(2000) // 2초 대기 (네트워크 요청 시뮬레이션)
return "데이터 받아옴!"
}
override fun onPostExecute(result: String?) {
textView.text = result
}
}
```
📌 **AsyncTask는 Deprecated 됐고, 지금은 코루틴을 사용해야 해!** 🚨
### 🔹 **최신 방식 (`Coroutine`)**
```
import kotlinx.coroutines.*
fun fetchData() {
GlobalScope.launch(Dispatchers.Main) {
val result = withContext(Dispatchers.IO) {
delay(2000L) // 2초 대기 (네트워크 요청 시뮬레이션)
"데이터 받아옴!"
}
textView.text = result
}
}
```
📌 **장점:**\
✔ `AsyncTask`보다 **더 간결하고 유지보수 쉬움**\
✔ **UI 업데이트를 안전하게 할 수 있음**\
✔ **비동기 네트워크 요청, 데이터 로딩할 때 사용하면 좋음**
* * * * *
✅ **4\. 최신 RecyclerView 방식 (Adapter 더 간단하게!)**
----------------------------------------------
✔ 예전에는 `RecyclerView.Adapter`를 만들 때 코드가 길었는데,\
✔ 이제 **ViewBinding + ViewHolder 패턴을 활용하면 더 간결하게 구현 가능!**
### 🔹 **최신 RecyclerView Adapter 예제**
```
class MyAdapter(private val items: List<String>) :
RecyclerView.Adapter<MyAdapter.ViewHolder>() {
class ViewHolder(val binding: ItemLayoutBinding) : RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val binding = ItemLayoutBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return ViewHolder(binding)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
holder.binding.textView.text = items[position]
}
override fun getItemCount() = items.size
}
```
📌 **`ViewBinding`을 활용해서 코드가 더 간결해짐!**
* * * * *
✅ **5\. 최신 네트워크 라이브러리 (Retrofit + Coroutine)**
----------------------------------------------
✔ 예전에는 **`HttpURLConnection` 또는 `AsyncTask`로 네트워크 요청**을 했는데,\
✔ **이제는 `Retrofit + Coroutine` 조합이 표준!**
### 🔹 **Retrofit + Coroutine 방식**
1. **`build.gradle`에 Retrofit 추가**
```
dependencies {
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}
```
1. **API 인터페이스 작성**
```
interface ApiService {
@GET("posts/1")
suspend fun getPost(): Post
}
```
1. **네트워크 요청 실행**
```
val api = Retrofit.Builder()
.baseUrl("https://jsonplaceholder.typicode.com/")
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(ApiService::class.java)
GlobalScope.launch(Dispatchers.Main) {
val post = api.getPost()
textView.text = post.title
}
```
📌 **장점:**\
✔ 네트워크 요청이 **비동기로 실행되므로 UI가 멈추지 않음!**\
✔ `Coroutine` 덕분에 **코드가 훨씬 깔끔해짐!**
* * * * *
✅ **6\. 최신 Navigation Component (화면 이동 최적화)**
---------------------------------------------
✔ **예전에는 `Intent`와 `FragmentManager`를 직접 사용했지만**,\
✔ **지금은 Jetpack Navigation을 사용하면 더 편리하게 화면 전환 가능!**
* * * * *
✅ **결론**
--------
📌 **기본적인 XML 기반 개발 방식은 예전과 거의 동일!**\
📌 **하지만 최신 방식(`ViewBinding`, `Coroutine`, `Retrofit`, `RecyclerView 개선`)이 도입됨!**\
📌 **예전처럼 해도 동작은 하지만, 최신 방식을 익히면 더 유지보수가 편하고 코드가 깔끔해짐!**
👉 **XML 기반으로 개발할 때도 최신 코틀린 스타일을 반영하면 더 편하게 개발할 수 있어!** 🚀\
### ✅ **Jetpack 라이브러리 vs Jetpack Compose, 같은 거야?**
❌ **완전히 같은 건 아니야!**\
**Jetpack Compose는 Jetpack 라이브러리의 일부(UI 관련 라이브러리)**이고,\
**Jetpack은 더 넓은 개념으로 다양한 Android 라이브러리의 모음**이야.
* * * * *
✅ **1\. Jetpack이란? (Jetpack = 안드로이드 필수 라이브러리 모음)**
--------------------------------------------------
**Jetpack은 안드로이드 개발을 쉽게 해주는 공식 라이브러리 모음**이야.\
Jetpack에는 여러 가지 라이브러리가 포함되어 있고, 그중 하나가 Jetpack Compose야.
✔ Jetpack = **안드로이드 개발을 위한 라이브러리 모음**\
✔ **UI, 데이터 저장, 비동기 처리, 권한 관리 등 다양한 기능 제공**\
✔ **대표적인 라이브러리:**
- **Jetpack Compose (UI)**
- **LiveData (데이터 관리)**
- **ViewModel (상태 관리)**
- **Room (데이터 저장, SQLite ORM)**
- **Navigation (화면 전환)**
- **WorkManager (백그라운드 작업)**
📌 **즉, Jetpack = 안드로이드 개발을 쉽게 만드는 다양한 라이브러리들의 묶음!**
* * * * *
✅ **2\. Jetpack Compose는 Jetpack의 일부 (UI 관련 라이브러리)**
----------------------------------------------------
✔ **Jetpack Compose는 UI를 코드로 만들기 위한 Jetpack 라이브러리**\
✔ 기존 XML 방식 대신 **Kotlin 코드로 UI를 직접 작성할 수 있음**\
✔ 하지만 Jetpack에는 **Compose 외에도 다양한 라이브러리들이 있음!**
* * * * *
✅ **3\. Jetpack 주요 라이브러리 정리**
-----------------------------
| **Jetpack 라이브러리** | **설명** |
| --- | --- |
| **Jetpack Compose** | UI를 XML 없이 Kotlin 코드로 직접 작성 |
| **ViewModel** | 화면 회전 시에도 데이터 유지 (수명 주기 관리) |
| **LiveData** | 데이터 변경을 자동으로 UI에 반영 |
| **Room** | SQLite를 쉽게 사용할 수 있는 ORM (데이터 저장) |
| **Navigation** | 화면 전환을 쉽게 관리하는 라이브러리 |
| **WorkManager** | 백그라운드에서 작업을 예약 실행 |
| **Paging** | RecyclerView의 페이징 처리 |
| **DataStore** | SharedPreferences를 대체하는 데이터 저장 방식 |
📌 **즉, Jetpack Compose는 Jetpack 라이브러리 중 UI 관련 부분만 담당하는 라이브러리야!**
* * * * *
✅ **4\. Jetpack을 XML 기반 개발에서도 사용할 수 있을까?**
------------------------------------------
✔ Jetpack Compose는 Jetpack의 일부지만,\
✔ **Jetpack 자체는 XML 기반 안드로이드 개발에서도 사용할 수 있음!**\
✔ **즉, Jetpack = XML 기반 UI + Jetpack Compose 모두 지원**\
✔ XML 기반으로 개발할 거라면 **ViewModel, LiveData, Room 같은 Jetpack 라이브러리는 여전히 유용함!**
* * * * *
✅ **5\. 결론**
------------
✔ **Jetpack = 안드로이드 개발 필수 라이브러리 모음**\
✔ **Jetpack Compose = Jetpack의 일부이며, UI 관련 라이브러리**\
✔ **XML 기반 개발에서도 Jetpack 라이브러리(ViewModel, LiveData, Room 등)를 사용할 수 있음**\
✔ **Compose는 UI 관련 Jetpack 라이브러리일 뿐, Jetpack 전체가 Compose인 건 아님!**
📌 **즉, Jetpack Compose는 Jetpack 라이브러리의 일부일 뿐, Jetpack 전체를 의미하는 건 아니야!** 🚀\
📌 **XML 기반으로 개발하더라도 Jetpack의 ViewModel, LiveData, Room 같은 기능들은 활용하면 좋음!**
댓글
댓글 쓰기