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

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

डिज़ाइन पैटर्न सॉफ्टवेयर विकास में सामान्य समस्याओं के सिद्ध समाधान हैं। यदि आपने पहले से ही बुनियादी पैटर्न (Singleton, Factory, Observer) में महारत हासिल कर ली है, तो अब अगले स्तर पर जाने का समय है। इस लेख में, हम चार उन्नत पैटर्न — चेन ऑफ रिस्पॉन्सिबिलिटी, इंटरप्रेटर, मीडिएटर और मेमेंटो — पर चर्चा करेंगे और भाषा के मुहावरों (sealed class, extension functions, लैम्ब्डा) को ध्यान में रखते हुए Kotlin में उनका कार्यान्वयन दिखाएंगे।

1. चेन ऑफ रिस्पॉन्सिबिलिटी (Chain of Responsibility)

उद्देश्य: अनुरोध को क्रमिक रूप से हैंडलर्स की श्रृंखला में भेजने की अनुमति देता है, जब तक कि उनमें से कोई एक अनुरोध को संसाधित न कर दे।

समस्या: एक लॉगिंग सिस्टम, जहां विभिन्न स्तरों (DEBUG, INFO, ERROR) के संदेशों को विभिन्न लॉगर्स द्वारा संसाधित किया जाना चाहिए।

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

// अमूर्त हैंडलर\nabstract class Logger(private val level: Int) {\n    private var nextLogger: Logger? = null\n\n    fun setNext(logger: Logger): Logger {\n        this.nextLogger = logger\n        return logger\n    }\n\n    fun log(level: Int, message: String) {\n        if (this.level <= level) {\n            write(message)\n        }\n        nextLogger?.log(level, message)\n    }\n\n    protected abstract fun write(message: String)\n}\n\n// ठोस हैंडलर\nclass ConsoleLogger(level: Int) : Logger(level) {\n    override fun write(message: String) = println("[Console] $message")\n}\n\nclass FileLogger(level: Int) : Logger(level) {\n    override fun write(message: String) = println("[File] $message")\n}\n\nclass EmailLogger(level: Int) : Logger(level) {\n    override fun write(message: String) = println("[Email] $message")\n}\n\n// उपयोग\nfun main() {\n    val logger = ConsoleLogger(1).apply {\n        setNext(FileLogger(2))\n            .setNext(EmailLogger(3))\n    }\n    logger.log(2, "चेतावनी: कम मेमोरी स्तर")\n    // आउटपुट:\n    // [Console] चेतावनी: कम मेमोरी स्तर\n    // [File] चेतावनी: कम मेमोरी स्तर\n}

Kotlin में लाभ: apply और setNext की श्रृंखलाबद्ध कॉल के कारण कोड संक्षिप्त दिखता है। अमूर्त वर्ग को डिफ़ॉल्ट कार्यान्वयन वाले इंटरफ़ेस से भी बदला जा सकता है।

2. इंटरप्रेटर (Interpreter)

उद्देश्य: भाषा के व्याकरण को परिभाषित करता है और उस भाषा के वाक्यों की व्याख्या करता है।

समस्या: सरल अंकगणितीय अभिव्यक्तियों (जैसे, "3 + 5 - 2") को पार्स और मूल्यांकन करने की आवश्यकता है।

sealed class के साथ Kotlin में कार्यान्वयन:

// अमूर्त अभिव्यक्ति\nsealed class Expression {\n    abstract fun interpret(): Int\n}\n\n// टर्मिनल अभिव्यक्ति — संख्या\ndata class Number(val value: Int) : Expression() {\n    override fun interpret() = value\n}\n\n// नॉन-टर्मिनल अभिव्यक्तियाँ — संक्रियाएँ\ndata class Add(val left: Expression, val right: Expression) : Expression() {\n    override fun interpret() = left.interpret() + right.interpret()\n}\n\ndata class Subtract(val left: Expression, val right: Expression) : Expression() {\n    override fun interpret() = left.interpret() - right.interpret()\n}\n\n// पार्सर (सरलीकृत)\nfun parse(tokens: List<String>): Expression {\n    val stack = mutableListOf<Expression>()\n    var i = 0\n    while (i < tokens.size) {\n        when (tokens[i]) {\n            "+" -> {\n                val right = Number(tokens[++i].toInt())\n                val left = stack.removeLast()\n                stack.add(Add(left, right))\n            }\n            "-" -> {\n                val right = Number(tokens[++i].toInt())\n                val left = stack.removeLast()\n                stack.add(Subtract(left, right))\n            }\n            else -> stack.add(Number(tokens[i]