मोबाइल डेवलपमेंट में Kotlin विशिष्टताएँ: यह क्या है, क्या संरचनाएँ और यह कैसे काम करता है

क्लासेज़ (data class, sealed class, object, companion object)

Kotlin Java से क्लास अवधारणाओं का विस्तार करता है। data class, sealed class, object और companion object — ऐसी संरचनाएँ जो Java में मौजूद नहीं हैं या अलग तरीके से लागू की गई हैं।

data class बनाम sealed class

data class — एक क्लास जो स्वचालित रूप से equals(), hashCode(), toString(), copy() और componentN() जनरेट करती है। डेटा मॉडल (DTO, Entity) के लिए आदर्श। आवश्यकताएँ: प्राथमिक कंस्ट्रक्टर में कम से कम एक पैरामीटर, val/var, open/sealed/inner नहीं हो सकता। sealed class — प्रतिबंधित उपवर्ग पदानुक्रम वाली क्लास। सभी उपवर्ग कंपाइल टाइम पर ज्ञात होते हैं और उसी फ़ाइल में घोषित किए जाते हैं। sealed class के साथ when एक्सप्रेशन को else ब्रांच की आवश्यकता नहीं होती। sealed interface (Kotlin 1.9+) — sealed class के समान लेकिन एकाधिक इनहेरिटेंस की अनुमति देता है। object — सिंगलटन, object कीवर्ड (class नहीं) से घोषित। थ्रेड-सेफ लेज़ी इनिशियलाइज़ेशन। companion object — क्लास के स्थैतिक सदस्य। इसका एक नाम होता है (डिफ़ॉल्ट रूप से Companion)। इंटरफ़ेस लागू कर सकता है और extension functions रख सकता है।

data class — 90% मॉडल के लिए। sealed class — UI State और परिणाम के लिए। object — सिंगलटन के लिए। IT Sectr सभी स्क्रीन अवस्थाओं (Loading, Success, Error) के लिए sealed class की अनुशंसा करता है।

व्यवहार में Sealed class

Sealed class — अवस्थाओं को मॉडल करने के लिए एक शक्तिशाली उपकरण। उदाहरण: UiState<T> उपवर्गों Loading, Success(data: T), Error(message: String) के साथ। when एक्सप्रेशन सभी अवस्थाओं की हैंडलिंग सुनिश्चित करता है। Sealed interface — ईवेंट और क्रियाओं के लिए जहाँ एकाधिक कार्यान्वयन की आवश्यकता है। Value class (Kotlin 1.5+) — बिना overhead के एक मान के लिए रैपर। टाइप-सेफ पहचानकर्ताओं के लिए उपयोग: @JvmInline value class UserId(val id: String).

फ़ंक्शन (extension, inline, higher-order, scope functions)

Extension Function — बिना इनहेरिटेंस के मौजूदा क्लास में विधि जोड़ना। fun String.isEmail(): Boolean. Extension Property — प्रॉपर्टी के लिए वही (बिना backing field के)। Inline Function — कॉल साइट पर फ़ंक्शन बॉडी डालना — बिना कॉल overhead के। लैम्ब्डा वाले higher-order फ़ंक्शन के लिए उपयोग। Higher-Order Function — एक फ़ंक्शन जो दूसरा फ़ंक्शन लेता या लौटाता है। Scope Functions — ऑब्जेक्ट संदर्भ के साथ काम करने के लिए पाँच फ़ंक्शन: let, run, with, apply, also.

Scope Functions

let — संदर्भ it, लैम्ब्डा परिणाम लौटाता है। null-safe कॉल के लिए उपयोग (?.let {}). apply — संदर्भ this, संदर्भ लौटाता है। ऑब्जेक्ट कॉन्फ़िगरेशन के लिए। run — संदर्भ this, लैम्ब्डा परिणाम लौटाता है। संदर्भ के साथ गणना के लिए। also — संदर्भ it, संदर्भ लौटाता है। साइड इफ़ेक्ट (लॉगिंग) के लिए। with — extension नहीं, संदर्भ this, लैम्ब्डा परिणाम लौटाता है। ऑब्जेक्ट पर संचालन के समूह के लिए। Lambda — अनाम फ़ंक्शन। Destructuring Declaration — data class को वेरिएबल में अनपैक करना: val (name, age) = person.

Inline + reified

Inline function reified के साथ — JVM में जेनेरिक टाइप संरक्षित करने का एकमात्र तरीका। उपयोग: टाइप-सेफ बिल्डर (Gson.fromJson<T>()), टाइप जाँच (is T), क्लास प्राप्त करना (T::class). Crossinline और Noinline — inline फ़ंक्शन में लैम्ब्डा पैरामीटर के लिए संशोधक। crossinline — non-local return को रोकता है, noinline — विशिष्ट लैम्ब्डा के इनलाइनिंग को रोकता है। IT Sectr केवल टाइप के साथ काम करते समय inline + reified की अनुशंसा करता है; सामान्य higher-order फ़ंक्शन के लिए, inline बाइटकोड आकार बढ़ा सकता है।

Coroutines (Coroutine Builder, Dispatchers, Scope)

Coroutines — एसिंक्रोनस प्रोग्रामिंग के लिए हल्के थ्रेड। थ्रेड को ब्लॉक नहीं करते — सस्पेंड होते हैं। suspend function — एक फ़ंक्शन जो थ्रेड को ब्लॉक किए बिना सस्पेंड हो सकता है। केवल coroutine या किसी अन्य suspend function से कॉल किया जा सकता है।

CoroutineScope

CoroutineScope — coroutines के लिए दायरा। इसमें CoroutineContext (Job + Dispatcher) होता है। lifecycleScope — Activity/Fragment के लिए (Lifecycle-aware). viewModelScope — ViewModel के लिए (onCleared() पर स्वचालित रद्दीकरण). GlobalScope — वैश्विक दायरा (प्रोडक्शन में उपयोग न करें — मेमोरी लीक). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (नेटवर्क/डिस्क), Dispatchers.Default (CPU-intensive), Dispatchers.Unconfined (अनुशंसित नहीं). launch — coroutine शुरू करना: Job. async — परिणाम के साथ शुरू करना: Deferred<T>. runBlocking — ब्लॉकिंग ब्रिज. withContext — suspend फ़ंक्शन के अंदर Dispatcher बदलना.

// ViewModel में डेटा लोड करना: coroutines उदाहरण
class MainViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    fun loadData() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val data = withContext(Dispatchers.IO) {
                    repository.fetchData()
                }
                _state.value = UiState.Success(data)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message)
            }
        }
    }
}

// async के साथ समानांतर अनुरोध
suspend fun loadCombinedData(): CombinedData = coroutineScope {
    val users = async(Dispatchers.IO) { api.getUsers() }
    val posts = async(Dispatchers.IO) { api.getPosts() }
    CombinedData(users.await(), posts.await())
}

viewModelScope.launch — ViewModel में मानक coroutine लॉन्च। withContext(Dispatchers.IO) — नेटवर्क अनुरोध के लिए IO थ्रेड पर स्विच करना। Dispatchers यह निर्धारित करते हैं कि coroutine किस थ्रेड पूल पर निष्पादित होती है। IT Sectr ViewModel के लिए viewModelScope और Activity/Fragment के लिए lifecycleScope की अनुशंसा करता है।

उन्नत सुविधाएँ (reified, destructuring, lateinit/lazy)

reified — inline फ़ंक्शन में टाइप संशोधक। टाइप का उपयोग करने की अनुमति देता है: T::class, is T, as T. reified के बिना, JVM में जेनेरिक मिट जाते हैं (type erasure). inline fun + reified — टाइप-सेफ API के लिए शक्तिशाली संयोजन। Destructuring Declaration — val (x, y) = point. data class और componentN() वाले टाइप के लिए काम करता है। typealias — टाइप उपनाम: typealias Callback = (String) -> Unit. lateinit — var का विलंबित इनिशियलाइज़ेशन (dependency injection के लिए). थ्रेड-सेफ नहीं। lazy — val का लेज़ी इनिशियलाइज़ेशन (डिफ़ॉल्ट रूप से थ्रेड-सेफ). lazy(LazyThreadSafetyMode.NONE) — बिना सिंक्रनाइज़ेशन के। Extension function और Extension property — बिना इनहेरिटेंस के कार्यक्षमता जोड़ना। Kotlin एक ऐसी भाषा है जहाँ extension functions 90% उपयोगिता कार्यों को हल करते हैं।

डेलिगेटेड प्रॉपर्टीज़

Delegated Properties — getter/setter को किसी अन्य ऑब्जेक्ट को सौंपना। मानक डेलिगेट: lazy, observable, vetoable, map. getValue/setValue ऑपरेटरों के माध्यम से कस्टम डेलिगेट। by — डेलिगेशन कीवर्ड: val name by lazy { loadName() }. डेलिगेटेड प्रॉपर्टीज़ ViewModel डेलिगेट (by viewModels()) का आधार हैं। IT Sectr विलंबित इनिशियलाइज़ेशन के लिए lazy और परिवर्तनों की निगरानी के लिए Delegates.observable की अनुशंसा करता है।

reified — टाइप-सेफ API के लिए। lazy — विलंबित लोडिंग के लिए। delegated properties — प्रॉपर्टी लॉजिक के पुन: उपयोग के लिए। IT Sectr प्रभावी Kotlin डेवलपमेंट के लिए इन सभी सुविधाओं में महारत हासिल करने की अनुशंसा करता है।

Flow और StateFlow

Flow — Kotlin में कोल्ड एसिंक्रोनस डेटा स्ट्रीम। कलेक्टर की माँग पर मान उत्सर्जित करता है। StateFlow — एकल वर्तमान मान वाला हॉट Flow। ViewModel में UI State के लिए उपयोग। SharedFlow — ईवेंट के लिए हॉट Flow (एक-शॉट ईवेंट). flowOf, asFlow — संग्रह से Flow बनाना। catch, retry, debounce — ऑपरेटर। stateIn, shareIn — कोल्ड Flow को हॉट में बदलना। IT Sectr UI State के लिए StateFlow और ईवेंट (Snackbar, नेविगेशन) के लिए SharedFlow की अनुशंसा करता है।

class SearchViewModel : ViewModel() {
    private val _query = MutableStateFlow("")
    val suggestions: StateFlow<List<String>> = _query
        .debounce(300)
        .filter { it.length >= 2 }
        .flatMapLatest { repository.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun onQueryChanged(query: String) {
        _query.value = query
    }
}

सीरियलाइज़ेशन (kotlinx.serialization, Parcelize)

kotlinx.serialization — JSON सीरियलाइज़ेशन के लिए Kotlin लाइब्रेरी। @Serializable — एनोटेशन। @SerialName — कस्टम फ़ील्ड नाम। समर्थन: JSON, CBOR, ProtoBuf. Parcelize — Android Parcelable के लिए @Parcelize (बिना मैन्युअल कार्यान्वयन के). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, कंपाइल-सेफ, बिना reflection के। Moshi — एनोटेशन + codegen. IT Sectr नए प्रोजेक्ट के लिए kotlinx.serialization और मौजूदा प्रोजेक्ट के लिए Moshi की अनुशंसा करता है।

@Serializable
data class ApiResponse<T>(
    val success: Boolean,
    @SerialName("data") val data: T? = null,
    val error: String? = null
)

@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// डिसीरियलाइज़ेशन
val json = Json { ignoreUnknownKeys = true }
val response = json.decodeFromString<ApiResponse<List<User>>>(jsonString)
println("Users: ${response.data?.size ?: 0}")