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

लेखक के बारे में:
Pavel Fatin JetBrains में IntelliJ IDEA के लिए एक स्काला प्लगइन पर काम कर रहा है।

परिचय

यह आलेख उदाहरण देगा कि क्लासिक स्काला डिज़ाइन पैटर्न कैसे लागू किया जाता है।

लेख की सामग्री जावाडाय सम्मेलन ( प्रस्तुति स्लाइड ) में मेरी प्रस्तुति का आधार बनती है ।

डिजाइन पैटर्न

सॉफ्टवेयर विकास में सामान्य समस्याओं के लिए डिजाइन पैटर्न एक सामान्य पुन: प्रयोज्य समाधान है। एक डिज़ाइन पैटर्न एक विशिष्ट समस्या को हल करने में उपयोग के लिए एक पूर्ण कोड नहीं है, लेकिन केवल एक टेम्पलेट जिसे विशिष्ट आवश्यकताओं के लिए अनुकूलित करने की आवश्यकता है। डिजाइन पैटर्न प्रभावी डिजाइन के लिए सर्वोत्तम अभ्यास हैं जो कोड की पठनीयता में सुधार करने और विकास प्रक्रिया को गति देने में मदद करते हैं।

कार्यात्मक डिजाइन पैटर्न

क्लासिक डिजाइन पैटर्न ऑब्जेक्ट ओरिएंटेड हैं। वे वर्गों और वस्तुओं के बीच संबंधों और संबंधों को दिखाते हैं। ये मॉडल विशुद्ध रूप से कार्यात्मक प्रोग्रामिंग में कम लागू होते हैं ("कार्यात्मक" डिज़ाइन पैटर्न के लिए हास्केल के टाइपक्लासोपेडिया और स्केलाज़ देखें), हालाँकि, चूंकि स्काला एक ऑब्जेक्ट- फ़ंक्शनल प्रोग्रामिंग भाषा है, इसलिए ये मॉडल स्काला कोड की कार्यात्मक दुनिया में भी प्रासंगिक हैं।

कभी-कभी, डिज़ाइन पैटर्न आवश्यक निर्माणों के लिए एक प्रतिस्थापन है जो प्रोग्रामिंग भाषा में नहीं हैं। उन मामलों में जहां भाषा में आवश्यक क्षमताएं हैं, पैटर्न को सरल बनाया जा सकता है या पूरी तरह से हटाया जा सकता है। स्काला दुनिया में, अभिव्यंजक वाक्य रचनाओं का उपयोग करके अधिकांश क्लासिक पैटर्न लागू किए जाते हैं।

स्काला के अपने अतिरिक्त पैटर्न हैं, लेकिन इस लेख में केवल शास्त्रीय डिजाइन पैटर्न का वर्णन किया जाएगा, क्योंकि वे डेवलपर्स के बीच आपसी समझ की कुंजी हैं।

इस तथ्य के बावजूद कि यहां प्रस्तुत उदाहरणों को अधिक स्पष्ट रूप से लागू किया जा सकता है, स्काला भाषा की पूरी शक्ति का उपयोग करते हुए, मैंने सरल और स्पष्ट लोगों के पक्ष में जटिल चाल से बचने की कोशिश की ताकि जावा कार्यान्वयन स्काला कार्यान्वयन से कैसे संबंधित हो, इसकी स्पष्ट समझ प्रदान कर सके।

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

जनरेटिव डिज़ाइन पैटर्न ( रचनात्मक पैटर्न ):

• फैक्टरी विधि
• आलसी आरंभीकरण
• सिंगलटन (सिंगलटन)

संरचनात्मक पैटर्न :

• एडाप्टर (एडाप्टर)
• डेकोरेटर (डेकोरेटर)

व्यवहार पैटर्न:

• मान वस्तु
• अशक्त वस्तु
• रणनीति (रणनीति)
• कमान (कमान)
• जिम्मेदारी की चेन
• निर्भरता इंजेक्शन

इसके बाद, डिज़ाइन पैटर्न लागू किया जाएगा (सभी कोड जीथब रिपॉजिटरी पर उपलब्ध है )।

डिजाइन पैटर्न का कार्यान्वयन

फैक्टरी विधि

फैक्ट्री मेथड पैटर्न का उपयोग ऑब्जेक्ट बनाने के लिए एक इंटरफेस प्रदान करने के लिए किया जाता है, यह निर्णय करता है कि ऑब्जेक्ट के किस वर्ग को बनाना है।

पैटर्न आपको इसकी अनुमति देता है:

• एक जटिल वस्तु बनाने के तर्क को संयोजित करें,
• ऑब्जेक्ट बनाने के लिए एक क्लास चुनें,
• कैश ऑब्जेक्ट्स
• साझा संसाधनों तक पहुंच का समन्वय करें।

स्टेटिक फैक्ट्री मेथड पैटर्न के कार्यान्वयन, जो कि फैक्ट्री मेथड पैटर्न के क्लासिक संस्करण से थोड़ा भिन्न होता है, नीचे वर्णित किया जाएगा । ।

जावा में , नए ऑपरेटर का उपयोग उसके निर्माता को कॉल करके एक वर्ग को तत्काल करने के लिए किया जाता है। टेम्पलेट को लागू करते समय, हम सीधे निर्माता का उपयोग नहीं करेंगे, लेकिन ऑब्जेक्ट बनाने के लिए एक विशेष विधि का उपयोग करेंगे।

public interface Animal {} 

 public class Dog implements Animal {} 

 public class Cat implements Animal {} 

 public class AnimalFactory { public static Animal createAnimal(String kind) { if ("cat".equals(kind)) { return new Cat(); } if ("dog".equals(kind)) { return new Dog(); } throw new IllegalArgumentException(); } } 

एक पैटर्न का उपयोग करने का एक उदाहरण एक कुत्ता बना रहा है।

 Animal animal = AnimalFactory.createAnimal("dog"); 

कंस्ट्रक्टरों के अलावा, स्काला एक विशेष सिंटैक्स निर्माण प्रदान करता है जो एक कंस्ट्रक्टर को कॉल करने के समान है, लेकिन वास्तव में एक सुविधाजनक कारखाना विधि है:

 trait Animal private class Dog extends Animal private class Cat extends Animal object Animal { def apply(kind: String) = kind match { case "dog" => new Dog() case "cat" => new Cat() } } 

उपयोग उदाहरण:

 Animal("dog") 

फैक्ट्री पद्धति को तथाकथित "साथी वस्तु" में परिभाषित किया गया है - एक विशेष सिंगलटन ऑब्जेक्ट जो समान स्रोत फ़ाइल में परिभाषित समान नाम के साथ है। यह सिंटैक्स पैटर्न के "स्थिर" कार्यान्वयन तक सीमित है, क्योंकि उप-वर्ग के लिए ऑब्जेक्ट के निर्माण को सौंपना असंभव हो जाता है।

पेशेवरों:

• बेस क्लास नाम का पुन: उपयोग करना।
• मानक और संक्षिप्त।
• डिजाइनर की एक कॉल की याद दिलाता है।

विपक्ष:

• "स्टेटिक" फैक्टरी विधि।

आलसी आरंभीकरण

आस्थगित आरंभीकरण आस्थगित कंप्यूटिंग का एक विशेष मामला है। यह पैटर्न केवल पहली पहुंच में एक मूल्य (या वस्तु) को शुरू करने के लिए एक तंत्र प्रदान करता है, जिससे आप कुछ महंगी गणनाओं को टाल सकते हैं (या बच सकते हैं)।

आमतौर पर, जावा में एक पैटर्न को लागू करते समय, एक विशेष नल मूल्य का उपयोग एक असंगठित राज्य को इंगित करने के लिए किया जाता है। लेकिन, यदि शून्य एक मान्य इनिशियलाइज़्ड वैल्यू है, तो इनिशियलाइज़ेशन स्टेट को इंगित करने के लिए एक अतिरिक्त ध्वज की आवश्यकता होती है। बहु-थ्रेडेड कोड में, दौड़ की स्थिति से बचने के लिए इस ध्वज तक पहुंच को सिंक्रनाइज़ किया जाना चाहिए। बेहतर सिंक्रनाइज़ेशन डबल-चेक लॉक का उपयोग कर सकता है, जो आगे कोड को जटिल करता है।

 private volatile Component component; public Component getComponent() { Component result = component; if (result == null) { synchronized(this) { result = component; if (result == null) { component = result = new Component(); } } } return result; } 

उपयोग उदाहरण:

 Component component = getComponent(); 

स्काला एक अधिक संक्षिप्त अंतर्निर्मित तंत्र प्रदान करता है:

 lazy val x = { print("(computing x) ") 42 } 

उपयोग उदाहरण:

 print("x = ") println(x) // x = (computing x) 42 

स्काला में विलंबित आरंभीकरण शून्य मानों के साथ भी बहुत अच्छा काम करता है। लंबित मूल्यों तक पहुंच सुरक्षित है।

आकर्षण आते हैं

• लघु वाक्य रचना।
• अशक्त मूल्यों का उपयोग अशक्त मूल्यों के लिए भी किया जा सकता है।
• लंबित मान थ्रेड सुरक्षित हैं।

विपक्ष

• आरंभीकरण पर कम नियंत्रण।

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

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

जावा में एक विशेष कीवर्ड स्थिर है , जो किसी भी वस्तु (वर्ग उदाहरण) के साथ संचार की कमी को इंगित करता है; इस कीवर्ड के साथ चिह्नित तरीके वंशानुक्रम के दौरान ओवरराइड नहीं किए जा सकते। इस तरह की अवधारणा मूल OOP सिद्धांत पर चलती है कि सब कुछ एक वस्तु है।

तो, इस पैटर्न का उपयोग तब किया जाता है जब कुछ इंटरफ़ेस के वैश्विक कार्यान्वयन के लिए उपयोग करना आवश्यक होता है (संभवतः विलंबित आरंभीकरण के साथ)।

 public class Cat implements Runnable { private static final Cat instance = new Cat(); private Cat() {} public void run() { // do nothing } public static Cat getInstance() { return instance; } } 

उपयोग उदाहरण:

 Cat.getInstance().run() 

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

स्काला इस पैटर्न को लागू करने के लिए एक कॉम्पैक्ट मैकेनिज्म प्रदान करता है।

 object Cat extends Runnable { def run() { // do nothing } } 

उपयोग उदाहरण:

 Cat.run() 

स्काला में, वस्तुएं कक्षाओं या इंटरफेस से विधियां प्राप्त कर सकती हैं। एक ऑब्जेक्ट को संदर्भित किया जा सकता है (सीधे या एक विरासत इंटरफ़ेस के माध्यम से)। स्काला में , वस्तुओं को मांग पर आस्थगित किया जाता है।

आकर्षण आते हैं

• पारदर्शी कार्यान्वयन।
• कॉम्पैक्ट सिंटैक्स।
• विलंबित आरंभीकरण।
• धागा सुरक्षित है।

विपक्ष

• आरंभीकरण पर कम नियंत्रण।

अनुकूलक

एडेप्टर पैटर्न एक इंटरफेस को दूसरे में परिवर्तित करने के लिए एक तंत्र प्रदान करता है, ताकि इन अलग-अलग इंटरफेस को लागू करने वाले वर्गों को एक साथ काम करने के लिए सक्षम किया जा सके।

मौजूदा घटकों को एकीकृत करने के लिए एडेप्टर सुविधाजनक हैं।

जावा में कार्यान्वयन एक रैपर क्लास बनाना है जो कोड में स्पष्ट रूप से उपयोग किया जाता है।

 public interface Log { void warning(String message); void error(String message); } public final class Logger { void log(Level level, String message) { /* ... */ } } public class LoggerToLogAdapter implements Log { private final Logger logger; public LoggerToLogAdapter(Logger logger) { this.logger = logger; } public void warning(String message) { logger.log(WARNING, message); } public void error(String message) { logger.log(ERROR, message); } } 

उपयोग उदाहरण:

 Log log = new LoggerToLogAdapter(new Logger()); 

स्कैला में एक विशेष अंतर्निहित तंत्र है जो इंटरफेस को बाधित करने के लिए - अंतर्निहित वर्ग।

 trait Log { def warning(message: String) def error(message: String) } final class Logger { def log(level: Level, message: String) { /* ... */ } } implicit class LoggerToLogAdapter(logger: Logger) extends Log { def warning(message: String) { logger.log(WARNING, message) } def error(message: String) { logger.log(ERROR, message) } } 

उपयोग उदाहरण:

 val log: Log = new Logger() 

यद्यपि लॉग प्रकार का उपयोग करने की उम्मीद है, स्काला संकलक लॉगगर वर्ग को तुरंत बदल देगा और इसे एक एडाप्टर के साथ लपेट देगा।

आकर्षण आते हैं

• पारदर्शी कार्यान्वयन।
• कॉम्पैक्ट सिंटैक्स।

विपक्ष

• आप एक आईडीई का उपयोग किए बिना भ्रमित हो सकते हैं।

डेकोरेटर (डेकोरेटर)

डेकोरेटर पैटर्न का उपयोग उसी वर्ग के अन्य उदाहरणों को प्रभावित किए बिना किसी वस्तु की कार्यक्षमता को बढ़ाने के लिए किया जाता है। डेकोरेटर विरासत का एक लचीला विकल्प प्रदान करता है। यह पैटर्न उपयोग करने के लिए सुविधाजनक है जब कार्यक्षमता को बढ़ाने के लिए कई स्वतंत्र तरीके हैं जिन्हें एक साथ मनमाने ढंग से जोड़ा जा सकता है।

जब जावा में लागू किया जाता है , तो एक नया डेकोरेटर वर्ग परिभाषित किया जाता है जो आधार इंटरफ़ेस को विरासत में लेता है और मूल वर्ग को लपेटता है ताकि कई सज्जाकारों को नेस्ट किया जा सके। एक मध्यवर्ती सज्जाकार वर्ग का उपयोग अक्सर कई विधियों को प्रस्तुत करने के लिए किया जाता है।

 public interface OutputStream { void write(byte b); void write(byte[] b); } public class FileOutputStream implements OutputStream { /* ... */ } public abstract class OutputStreamDecorator implements OutputStream { protected final OutputStream delegate; protected OutputStreamDecorator(OutputStream delegate) { this.delegate = delegate; } public void write(byte b) { delegate.write(b); } public void write(byte[] b) { delegate.write(b); } } public class BufferedOutputStream extends OutputStreamDecorator { public BufferedOutputStream(OutputStream delegate) { super(delegate); } public void write(byte b) { // ... delegate.write(buffer) } } 

उपयोग उदाहरण:

 new BufferedOutputStream(new FileOutputStream("foo.txt")); 

एक ही लक्ष्य को प्राप्त करने के लिए, स्काला अपने विशिष्ट कार्यान्वयन से बंधे बिना, इंटरफ़ेस विधियों को ओवरराइड करने का एक सीधा तरीका प्रदान करता है।

 trait OutputStream { def write(b: Byte) def write(b: Array[Byte]) } class FileOutputStream(path: String) extends OutputStream { /* ... */ } trait Buffering extends OutputStream { abstract override def write(b: Byte) { // ... super.write(buffer) } } 

उपयोग उदाहरण:

 new FileOutputStream("foo.txt") with Buffering // with Filtering, ... 

प्रत्यायोजन संकलित समय पर विधिवत रूप से निर्धारित किया जाता है, लेकिन यह आमतौर पर तब तक पर्याप्त होता है जब तक हम मनमाने ढंग से डेकोरेटर को उस समय बना सकते हैं जब ऑब्जेक्ट बनाया जाता है।

संरचना-आधारित कार्यान्वयन के विपरीत, स्काला दृष्टिकोण वस्तु की पहचान को संरक्षित करता है, इसलिए आप सुरक्षित रूप से सजाए गए ऑब्जेक्ट पर समान रूप से उपयोग कर सकते हैं।

स्काला में, इस सजावट के दृष्टिकोण को स्टैकेबल ट्रेट पैटर्न कहा जाता है।

आकर्षण आते हैं

• पारदर्शी कार्यान्वयन।
• कॉम्पैक्ट सिंटैक्स।
• वस्तुओं की पहचान बचाई गई है।
• स्पष्ट प्रतिनिधिमंडल का अभाव।
• मध्यवर्ती सज्जाकार वर्ग का अभाव।

विपक्ष

• स्थैतिक बंधन।
• मापदंडों के बिना निर्माता।

मान वस्तु

मान ऑब्जेक्ट एक छोटा अपरिवर्तनीय मान है। यदि उनके सभी फ़ील्ड समान हैं, तो मान ऑब्जेक्ट समान हैं। संख्या, दिनांक, रंग आदि का प्रतिनिधित्व करने के लिए मूल्य वस्तुओं का व्यापक रूप से उपयोग किया जाता है। कॉर्पोरेट अनुप्रयोगों में, ऐसी वस्तुओं को प्रक्रियाओं के बीच बातचीत के लिए डीटीओ ऑब्जेक्ट के रूप में उपयोग किया जाता है, क्योंकि अपरिवर्तनीयता के कारण, बहु-थ्रेडेड प्रोग्रामिंग में मूल्य ऑब्जेक्ट सुविधाजनक होते हैं।

मूल्य वस्तुओं को बनाने के लिए जावा में कोई विशेष वाक्यविन्यास नहीं है; इसके बजाय, एक वर्ग का निर्माण, गेटर तरीकों और अतिरिक्त तरीकों (बराबर, हैशकोड, स्ट्रींग) के साथ किया जाता है।

 public class Point { private final int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; } public boolean equals(Object o) { // ... return x == that.x && y == that.y; } public int hashCode() { return 31 * x + y; } public String toString() { return String.format("Point(%d, %d)", x, y); } } 

उपयोग उदाहरण:

 Point point = new Point(1, 2) 

स्काला में , आप मूल्य वस्तुओं को घोषित करने के लिए ट्यूपल्स या केस कक्षाओं का उपयोग कर सकते हैं। जब एक अलग केस क्लास की जरूरत नहीं है, तो आप ट्यूपल्स का उपयोग कर सकते हैं:

 val point = (1, 2) // new Tuple2(1, 2) 

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

 type Point = (Int, Int) // Tuple2[Int, Int] val point: Point = (1, 2) 

ऐसे मामलों में जहां एक प्रतिष्ठित वर्ग आवश्यक है, या जब डेटा तत्वों के लिए अधिक वर्णनात्मक नाम आवश्यक हैं, तो आप एक केस क्लास को परिभाषित कर सकते हैं:

 case class Point(x: Int, y: Int) val point = Point(1, 2) 

केस क्लासेस क्लास कंस्ट्रक्टर पैरामीटर गुण बनाते हैं। डिफ़ॉल्ट रूप से, केस कक्षाएं अपरिवर्तनीय हैं। ट्यूपल्स की तरह, वे सभी आवश्यक तरीके स्वचालित रूप से प्रदान करते हैं। इसके अलावा, मामले की कक्षाएं वैध कक्षाएं हैं, जिसका अर्थ है कि आप उनके साथ साधारण कक्षाओं की तरह काम कर सकते हैं (उदाहरण के लिए, उनसे विरासत में)।

आकर्षण आते हैं

• कॉम्पैक्ट सिंटैक्स।
• पूर्वनिर्धारित भाषा निर्माण टुपल्स हैं।
• अंतर्निहित आवश्यक तरीके।

विपक्ष

अनुपस्थित हैं।

अशक्त वस्तुएँ

एक अशक्त वस्तु एक निष्पक्ष, "निष्क्रिय" व्यवहार को परिभाषित करते हुए एक वस्तु की अनुपस्थिति है।

यह दृष्टिकोण अशक्त लिंक का उपयोग करने पर पूर्वता लेता है, क्योंकि उपयोग से पहले लिंक को स्पष्ट रूप से जांचने की कोई आवश्यकता नहीं है।

जावा में, पैटर्न का कार्यान्वयन "खाली" विधियों के साथ एक विशेष उपवर्ग बनाने के लिए है:

 public interface Sound { void play(); } public class Music implements Sound { public void play() { /* ... */ } } public class NullSound implements Sound { public void play() {} } public class SoundSource { public static Sound getSound() { return available ? music : new NullSound(); } } SoundSource.getSound().play(); 

अब जब प्ले विधि के लिए अगली कॉल से पहले गेटसाउंड विधि को कॉल किया गया था, तो प्राप्त लिंक की जांच करने की कोई आवश्यकता नहीं है। इसके अलावा, एक अशक्त वस्तु को एक सिंगलटन बनाया जा सकता है।

Scala पूर्वनिर्धारित विकल्प प्रकार का उपयोग करके एक समान दृष्टिकोण का उपयोग करता है, जिसे वैकल्पिक मूल्य के "कंटेनर" के रूप में इस्तेमाल किया जा सकता है:

 trait Sound { def play() } class Music extends Sound { def play() { /* ... */ } } object SoundSource { def getSound: Option[Sound] = if (available) Some(music) else None } for (sound <- SoundSource.getSound) { sound.play() } 

आकर्षण आते हैं

• पूर्वनिर्धारित प्रकार।
• स्पष्ट पर्याय।
• वैकल्पिक मूल्यों के साथ काम करने के लिए अंतर्निहित भाषा का निर्माण।

विपक्ष

• शब्दाडंबर।

रणनीति (रणनीति)

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

जावा में , आमतौर पर एक वर्ग को लागू किया जाता है, जो आधार इंटरफेस को विरासत में देने वाली कक्षाओं की एक पदानुक्रम बनाकर लागू होता है:

 public interface Strategy { int compute(int a, int b); } public class Add implements Strategy { public int compute(int a, int b) { return a + b; } } public class Multiply implements Strategy { public int compute(int a, int b) { return a * b; } } public class Context { private final Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public void use(int a, int b) { strategy.compute(a, b); } } new Context(new Multiply()).use(2, 3); 

स्काला में प्रथम श्रेणी के कार्य होते हैं, इसलिए एक पैटर्न की अवधारणा को भाषा का उपयोग करके लागू किया जाता है:

 type Strategy = (Int, Int) => Int class Context(computer: Strategy) { def use(a: Int, b: Int) { computer(a, b) } } val add: Strategy = _ + _ val multiply: Strategy = _ * _ new Context(multiply).use(2, 3) 

उस स्थिति में जहां रणनीति एल्गोरिथ्म में कई विधियां शामिल हैं, आप केस कक्षाओं या समूह विधियों के लिए एक टपल का उपयोग कर सकते हैं।

आकर्षण आते हैं

• कॉम्पैक्ट सिंटैक्स।

विपक्ष

• सामान्य प्रयोजन।

कमान (कमान)

पैटर्न कमांड का उपयोग किसी दूरस्थ समय पर विधि को लागू करने के लिए आवश्यक जानकारी को एनकोड करने के लिए किया जाता है। इस जानकारी में विधि का नाम, वह वस्तु जिसके पास विधि है, और विधि के मापदंडों के मान शामिल हैं।

जावा में, किसी वस्तु में कॉल को लपेटने के लिए एक पैटर्न का कार्यान्वयन होता है।

 public class PrintCommand implements Runnable { private final String s; PrintCommand(String s) { this.s = s; } public void run() { System.out.println(s); } } public class Invoker { private final List<Runnable> history = new ArrayList<>(); void invoke(Runnable command) { command.run(); history.add(command); } } Invoker invoker = new Invoker(); invoker.invoke(new PrintCommand("foo")); invoker.invoke(new PrintCommand("bar")); 

स्काला में आस्थगित कंप्यूटिंग के लिए एक विशेष तंत्र है:

 object Invoker { private var history: Seq[() => Unit] = Seq.empty def invoke(command: => Unit) { // by-name parameter command history :+= command _ } } Invoker.invoke(println("foo")) Invoker.invoke { println("bar 1") println("bar 2") } 

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

आकर्षण आते हैं

• कॉम्पैक्ट सिंटैक्स।

विपक्ष

• सामान्य प्रयोजन।

जिम्मेदारी की श्रृंखला

जिम्मेदारी पैटर्न की श्रृंखला अपने प्राप्तकर्ता से अनुरोध के प्रेषक को अलग करती है, जिससे कई संस्थाएं अनुरोध को संसाधित कर सकती हैं। अनुरोध को तब तक श्रृंखला द्वारा संसाधित किया जाता है जब तक कि कोई वस्तु इसे संसाधित नहीं करती है।

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

 public abstract class EventHandler { private EventHandler next; void setNext(EventHandler handler) { next = handler; } public void handle(Event event) { if (canHandle(event)) doHandle(event); else if (next != null) next.handle(event); } abstract protected boolean canHandle(Event event); abstract protected void doHandle(Event event); } public class KeyboardHandler extends EventHandler { // MouseHandler... protected boolean canHandle(Event event) { return "keyboard".equals(event.getSource()); } protected void doHandle(Event event) { /* ... */ } } 

उपयोग उदाहरण:

 KeyboardHandler handler = new KeyboardHandler(); handler.setNext(new MouseHandler()); 

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

हालांकि isDefinedAt और लागू विधियों के संयोजन का उपयोग श्रृंखला के निर्माण के लिए किया जा सकता है, यह getOrElse विधि का उपयोग करने के लिए अधिक उपयुक्त होगा

 case class Event(source: String) type EventHandler = PartialFunction[Event, Unit] val defaultHandler: EventHandler = PartialFunction(_ => ()) val keyboardHandler: EventHandler = { case Event("keyboard") => /* ... */ } def mouseHandler(delay: Int): EventHandler = { case Event("mouse") => /* ... */ } 

 keyboardHandler.orElse(mouseHandler(100)).orElse(defaultHandler) 

यह ध्यान रखना महत्वपूर्ण है कि "अपरिभाषित" घटनाओं पर त्रुटियों से बचने के लिए डिफ़ॉल्टहैंडलर का उपयोग यहां किया जाता है ।

आकर्षण आते हैं

• कॉम्पैक्ट सिंटैक्स।
• निर्मित भाषा निर्माण।

विपक्ष

• सामान्य प्रयोजन।

निर्भरता इंजेक्शन

निर्भरता इंजेक्शन पैटर्न रन-टाइम पर या संकलन के समय हार्ड-कोडेड निर्भरता और विकल्प निर्भरता से बचता है। एक पैटर्न कंट्रोल ऑफ कंट्रोल (IoC) का एक विशेष मामला है।

डिपेंडेंसी इंजेक्शन का उपयोग किसी एप्लिकेशन में किसी विशेष घटक के कार्यान्वयन के विभिन्न प्रकारों में से चयन करने के लिए या इकाई परीक्षण के लिए नकली घटक प्रदान करने के लिए किया जाता है ।

आईओसी कंटेनरों का उपयोग करने के अलावा, इस पैटर्न को जावा में लागू करने का सबसे सरल तरीका कंस्ट्रक्टर मापदंडों के माध्यम से इंटरफेस (जो अपने काम में वर्ग का उपयोग करता है) के विशिष्ट कार्यान्वयन को पारित करना है।

 public interface Repository { void save(User user); } public class DatabaseRepository implements Repository { /* ... */ } public class UserService { private final Repository repository; UserService(Repository repository) { this.repository = repository; } void create(User user) { // ... repository.save(user); } } new UserService(new DatabaseRepository()); 

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

आप निर्भरता इंजेक्शन पैटर्न को लागू करने के लिए लक्षणों के साथ स्व-प्रकार के एनोटेशन का उपयोग कर सकते हैं:

 trait Repository { def save(user: User) } trait DatabaseRepository extends Repository { /* ... */ } trait UserService { self: Repository => // requires Repository def create(user: User) { // ... save(user) } } new UserService with DatabaseRepository 

इस पद्धति का पूर्ण कार्यान्वयन केक पैटर्न के रूप में जाना जाता है। हालांकि, यह पैटर्न को लागू करने का एकमात्र तरीका नहीं है; स्काला में निर्भरता इंजेक्शन पैटर्न को लागू करने के कई अन्य तरीके भी हैं।

यह याद रखना महत्वपूर्ण है कि स्काला में लक्षणों का "मिश्रण" स्थिर है, संकलन समय पर होता है। हालाँकि, व्यवहार में, कॉन्फ़िगरेशन परिवर्तन की इतनी बार आवश्यकता नहीं होती है, और संकलन चरण पर स्थैतिक सत्यापन के अतिरिक्त लाभों का XML कॉन्फ़िगरेशन पर महत्वपूर्ण लाभ होता है।

आकर्षण आते हैं

• पारदर्शी कार्यान्वयन।
• कॉम्पैक्ट सिंटैक्स।
• संकलन समय पर स्थैतिक जाँच।

विपक्ष

• संकलन चरण में विन्यास।
• कॉन्फ़िगरेशन क्रिया बन सकता है।

निष्कर्ष

मुझे आशा है कि यह डेमो जावा प्रोग्रामर्स को स्काला सिंटैक्स को समझने में मदद करने के लिए दो भाषाओं के बीच की खाई को पाटने में मदद करता है, और स्काला प्रोग्रामर को विशिष्ट भाषा निर्माणों को अच्छी तरह से ज्ञात सार में मैप करने में मदद करता है।