कोटलिन डिजाइन पैटर्न

वे कहते हैं कि "डिज़ाइन पैटर्न एक विशेष प्रोग्रामिंग भाषा की कमियों के लिए वर्कअराउंड हैं।" एक दिलचस्प प्रस्ताव, यदि केवल यह नहीं कहा गया था माफी देने वाले लिस्प और स्कीमा ।

लेकिन ऐसा लगता है कि कोटलिन भाषा के डेवलपर्स ने इस कथन को वास्तव में दिल से लिया।

एकल (सिंगलटन)

बेशक, दिमाग में आने वाला पहला पैटर्न लोनेर है। और इसे सीधे भाषा में ऑब्जेक्ट कीवर्ड के रूप में बनाया जाता है:

object JustSingleton { val value : String = "Just a value" } 

अब JustSingleton.value फ़ील्ड पैकेज में कहीं से भी सुलभ होगी।

और नहीं, यह स्थैतिक आरंभीकरण नहीं है, क्योंकि यह लग सकता है। आइए इस क्षेत्र को कुछ देरी से शुरू करने की कोशिश करते हैं:

 object SlowSingleton { val value : String init { var uuid = "" val total = measureTimeMillis { println("Computing") for (i in 1..10_000_000) { uuid = UUID.randomUUID().toString() } } value = uuid println("Done computing in ${total}ms") } } 

पहली कॉल पर आलसी इनिशियलाइज़ेशन होता है:

 @org.testng.annotations.Test fun testSingleton() { println("Test started") for (i in 1..3) { val total = measureTimeMillis { println(SlowSingleton.value) } println("Took $total ms") } } 

आउटपुट है:

 Test started Computing Done computing in 5376ms "45f7d567-9b3e-4099-98e6-569ebc26ecdf" Took 5377 ms "45f7d567-9b3e-4099-98e6-569ebc26ecdf" Took 0 ms "45f7d567-9b3e-4099-98e6-569ebc26ecdf" Took 0 ms 

कृपया ध्यान दें कि यदि आप इस ऑब्जेक्ट का उपयोग नहीं करते हैं, तो ऑपरेशन में 0 एमएस लगता है, हालांकि ऑब्जेक्ट अभी भी आपके कोड में परिभाषित है।

 val total = measureTimeMillis { //println(SlowSingleton.value) } 

आउटपुट:

 Test started Took 0 ms Took 0 ms Took 0 ms 

डेकोरेटर

इसके बाद डेकोरेटर आता है। यह एक पैटर्न है जो आपको किसी अन्य वर्ग के शीर्ष पर थोड़ी कार्यक्षमता जोड़ने की अनुमति देता है। हां, IntelliJ इसे आपके लिए बना सकता है। लेकिन कोटलिन और भी आगे बढ़ गए।

कैसे हर बार जब हम हाशप में एक नई कुंजी जोड़ते हैं, तो हमें इस बारे में एक संदेश मिलता है?

कंस्ट्रक्टर में, आप एक ऐसे उदाहरण को परिभाषित करते हैं, जिसके द्वारा सभी विधियों को कीवर्ड द्वारा प्रयोग किया जाता है।

 /** * Using `by` keyword you can delegate all but overridden methods */ class HappyMap<K, V>(val map : MutableMap<K, V> = mutableMapOf()) : MutableMap<K, V> by map{ override fun put(key: K, value: V): V? { return map.put(key, value).apply { if (this == null) { println("Yay! $key") } } } } 

ध्यान दें कि हम अपने नक्शे के तत्वों को वर्ग कोष्ठक के माध्यम से एक्सेस कर सकते हैं और अन्य सभी तरीकों का उसी तरह उपयोग कर सकते हैं जैसे एक नियमित हाशप में।

 @org.testng.annotations.Test fun testDecorator() { val map = HappyMap<String, String>() val result = captureOutput { map["A"] = "B" map["B"] = "C" map["A"] = "C" map.remove("A") map["A"] = "C" } assertEquals(mapOf("A" to "C", "B" to "C"), map.map) assertEquals(listOf("Yay! A", "Yay! B", "Yay! A"), (result)) } 

फैक्टरी विधि

कंपेनियन ऑब्जेक्ट फैक्ट्री मेथड को लागू करना आसान बनाता है। यह वह पैटर्न है जिसके द्वारा वस्तु अपने भीतर कुछ रहस्यों को छुपाने के लिए अपनी आरंभिक प्रक्रिया को नियंत्रित करती है।

 class SecretiveGirl private constructor(val age: Int, val name: String = "A girl has no name", val desires: String = "A girl has no desires") { companion object { fun newGirl(vararg desires : String) : SecretiveGirl { return SecretiveGirl(17, desires = desires.joinToString(", ")) } fun newGirl(name : String) : SecretiveGirl { return SecretiveGirl(17, name = name) } } } 

अब कोई भी व्यक्ति SecretiveGirl की उम्र नहीं बदल सकता है:

 @org.testng.annotations.Test fun FactoryMethodTest() { // Cannot do this, constructor is private // val arya = SecretiveGirl(); val arya1 = SecretiveGirl.newGirl("Arry") assertEquals(17, arya1.age) assertEquals("Arry", arya1.name) assertEquals("A girl has no desires", arya1.desires) val arya2 = SecretiveGirl.newGirl("Cersei Lannister", "Joffrey", "Ilyn Payne") assertEquals(17, arya2.age) assertEquals("A girl has no name", arya2.name) assertEquals("Cersei Lannister, Joffrey, Ilyn Payne", arya2.desires) } 

रणनीति

आज के लिए अंतिम एक रणनीति है । चूंकि कोटलिन के पास उच्च-क्रम के कार्य हैं , इसलिए इस पैटर्न को लागू करना भी बहुत सरल है:

 class UncertainAnimal { var makeSound = fun () { println("Meow!") } } 

और गतिशील रूप से व्यवहार को बदलें:

 @org.testng.annotations.Test fun testStrategy() { val someAnimal = UncertainAnimal() val output = captureOutput { someAnimal.makeSound() someAnimal.makeSound = fun () { println("Woof!") } someAnimal.makeSound() } assertEquals(listOf("Meow!", "Woof!"), output) } 

कृपया ध्यान दें कि यह वास्तव में एक रणनीति पैटर्न है, और आप विधि हस्ताक्षर (हैलो, JS!) नहीं बदल सकते।

 // Won't compile! someAnimal.makeSound = fun (message : String) { println("$message") } 

सभी कोड मेरे GitHub पेज पर उपलब्ध है।

और यदि आप कोटलिन और इसके अंतर्निहित डिजाइन पैटर्न के बारे में अधिक जानने में रुचि रखते हैं, तो एक महान पुस्तक है, "कोटलिन इन एक्शन" । आप इसे पसंद करेंगे भले ही आप निकट भविष्य में इस भाषा का उपयोग करने की योजना न करें (हालांकि कोई कारण नहीं है)।