घटकों और इंटरफेस के बारे में। जावा

प्रविष्टि

पिछले लेख में, मैंने घटकों को इंटरफेस डिजाइन करने और C ++ में उनके कार्यान्वयन को छिपाने के विभिन्न तरीकों के बारे में लिखा था।
इस लेख में, मैं संक्षेप में जावा में एक कार्यान्वयन से एक इंटरफ़ेस को अलग करने और एक कार्यान्वयन को छिपाने का तरीका बताऊंगा।
मैं वहां विभिन्न जावा ईई के घटकों पर विचार नहीं करूंगा, मैं सबसे सामान्य जार-उपनामों पर विचार करूंगा।
So.

हमारे पास क्या है?

जावा में कोई फ़ंक्शन नहीं हैं, केवल कक्षाएं; तदनुसार, कक्षाओं को जावा में निर्यात किया जाता है।
निर्यात किए जाने वाले वर्ग के लिए, इसे सार्वजनिक घोषित किया जाना चाहिए।
इसलिए, लाइब्रेरी इंटरफ़ेस लिखने के लिए, आपको वास्तव में, लाइब्रेरी की आवश्यकता है और निर्यात की गई कक्षाओं को सार्वजनिक घोषित करना होगा।

कुछ इस तरह:

package com.test; public class Test { private final String string = "Test"; public String GetString() { return string; } } 

संकलन करें, हमें एक जार उपनाम मिलता है, जो तब उपयोग कर सकता है।
खैर, कुछ इस तरह से:

 package com.sample; import com.test.Test; public class NewClass { private static Test test = new Test(); public static void Main() { System.out.println( test.GetString() ); } } 

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

क्या हुआ?

उदाहरण के लिए, हमारे पास इस इंटरफ़ेस के साथ एक घटक है:

 package com.iface; public interface Component { public void Method1(); public void Method2(); public void Method3(); public void Method4(); } 

हम एक कारखाने द्वारा घटक का उदाहरण बनाते हैं जो इस इंटरफ़ेस को लागू करता है:

 package com.iface; public interface Factory { public Component getComponent(); } 

हम सांख्यिकीय रूप से एक कारखाना उदाहरण बनाते हैं। हम कारखाने के लिए लिंक रखते हैं। हम इस प्रकार के रूप में FactoryCreator वर्ग शैली:

 package com.iface; import java.lang.reflect.Method; public class FactoryCreator { private static Factory instance = null; private static Throwable ex = null; static { try { Class cl = Class.forName("com.test.FactoryImpl"); Method method = cl.getMethod("createInstance", new Class[0]); Object obj = method.invoke(cl, new Object[0]); if(obj instanceof Factory) { instance = (Factory) obj; } ex = new Exception("Cannot init Factory instance."); } catch (Throwable throwable) { ex = throwable; } } public static Factory getInstance() throws Throwable { if(instance != null) { return instance; } throw ex; } } 

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

सारांश

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