Kotlin में डिज़ाइन पैटर्न कोड उदाहरणों के साथ

Kotlin में डिज़ाइन पैटर्न उदाहरण सहित

डिज़ाइन पैटर्न सॉफ़्टवेयर विकास में सामान्य समस्याओं के सिद्ध समाधान हैं। वे लचीली, स्केलेबल और रखरखाव योग्य आर्किटेक्चर बनाने में मदद करते हैं। Kotlin भाषा में, इसके संक्षिप्त सिंटैक्स और कार्यात्मक क्षमताओं के कारण, कई क्लासिक पैटर्न विशेष रूप से सुंदर ढंग से लागू किए जाते हैं। इस लेख में, हम तीन प्रमुख पैटर्न: Singleton, Factory Method और Observer पर चर्चा करेंगे, और व्यावहारिक उदाहरणों के साथ Kotlin में उनका कार्यान्वयन दिखाएंगे।

1. Singleton (सिंगलटन)

Singleton पैटर्न सुनिश्चित करता है कि क्लास का केवल एक इंस्टेंस हो, और उस तक वैश्विक पहुँच प्रदान करता है। Kotlin में इसके लिए एक अंतर्निहित संरचना है — object। यह बिना अतिरिक्त कोड के थ्रेड-सेफ सिंगलटन बनाता है।

Kotlin में कार्यान्वयन

सिंगलटन घोषित करने का सबसे सरल तरीका object कीवर्ड का उपयोग करना है:

object DatabaseConfig {    private val url = "jdbc:postgresql://localhost:5432/mydb"    private val username = "admin"    private val password = "secret"

    fun connect(): String {        return "$username के रूप में $url से कनेक्शन"    }}

fun main() {    println(DatabaseConfig.connect())    // आउटपुट: admin के रूप में jdbc:postgresql://localhost:5432/mydb से कनेक्शन}

यदि प्राइवेट कंस्ट्रक्टर के साथ क्लासिक Singleton की आवश्यकता है (उदाहरण के लिए, किसी अन्य क्लास से इनहेरिट करने के लिए), तो companion object का उपयोग करें:

class Logger private constructor() {    fun log(message: String) {        println("[LOG]: $message")    }

    companion object {        private val instance: Logger by lazy { Logger() }

        fun getInstance(): Logger {            return instance        }    }}

fun main() {    val logger = Logger.getInstance()    logger.log("एप्लिकेशन शुरू हुआ")}

by lazy दृष्टिकोण का लाभ लेज़ी इनिशियलाइज़ेशन है, जो केवल पहली बार एक्सेस करने पर ही निष्पादित होता है।

2. Factory Method (फ़ैक्टरी मेथड)

Factory Method पैटर्न ऑब्जेक्ट बनाने के लिए एक इंटरफ़ेस परिभाषित करता है, लेकिन सबक्लास को बनाए जाने वाले ऑब्जेक्ट के प्रकार को बदलने की अनुमति देता है। Kotlin में इसे अक्सर sealed class या इंटरफ़ेस के माध्यम से लागू किया जाता है।

Kotlin में कार्यान्वयन

मान लीजिए हम एक नोटिफिकेशन सिस्टम विकसित कर रहे हैं। हमारे पास विभिन्न प्रकार के नोटिफिकेशन हैं: Email, SMS और Push। आइए उन्हें जनरेट करने के लिए एक फ़ैक्टरी बनाएं।

// सभी नोटिफिकेशन के लिए इंटरफ़ेसinterface Notification {    fun send(message: String)}

// विशिष्ट कार्यान्वयनclass EmailNotification : Notification {    override fun send(message: String) {        println("Email भेजा जा रहा है: $message")    }}

class SMSNotification : Notification {    override fun send(message: String) {        println("SMS भेजा जा रहा है: $message")    }}

class PushNotification : Notification {    override fun send(message: String) {        println("Push सूचना भेजी जा रही है: $message")    }}

// फ़ैक्टरीobject NotificationFactory {    fun createNotification(type: String): Notification {        return when (type.lowercase()) {            "email" -> EmailNotification()            "sms" -> SMSNotification()            "push" -> PushNotification()            else -> throw IllegalArgumentException("अज्ञात नोटिफिकेशन प्रकार: $type")        }    }}

fun main() {    val notification = NotificationFactory.createNotification("sms")    notification.send("आपका पुष्टिकरण कोड: 1234")    // आउटपुट: SMS भेजा जा रहा है: आपका पुष्टिकरण कोड: 1234}

यदि प्रकारों की संख्या निश्चित है, तो अधिक सुरक्षा के लिए sealed class का उपयोग करना बेहतर है:

sealed class NotificationType {    object Email : NotificationType()    object SMS : NotificationType()    object Push : NotificationType()}

fun createNotification(type: NotificationType): Notificat
```