दिलचस्प पोस्ट
गतिशील सेल लेआउट और चर पंक्ति हाइट्स के लिए UITableView में ऑटो लेआउट का उपयोग करना `स्थिर कन्स्ट्रक्शन` बनाम 'कंट' के सी ++ अर्थशास्त्र JSON की एक सतत स्ट्रीम की प्रक्रिया करें पता करें कि रेडियो बटन JQuery के साथ चेक किया गया है या नहीं? Int को 4 बाइट्स कन्वर्ट करें JQuery AJAX को httpget webmethod (c #) काम नहीं कर रहा है कैसे एक स्ट्रिंग संख्यात्मक है की जांच करने के लिए? यदि मूल्य * है * निर्दिष्ट निर्दिष्ट एक है, तो समारोह से बाहर नहीं java.lang.IllegalStateException com.sun.faces.context.facesContextImpl.assertNot पर रिलीज़ किया गया रेल अनुप्रयोगों में लंबे आईडी का उपयोग कैसे करें? क्या आप समापन समझा सकते हैं (जैसा कि वे पायथन से संबंधित हैं)? आईओएस में स्थिति पट्टी कैसे छिपाएगी? क्या मैं UIWebViewDelegate के अंदर चेतावनी को संभाल सकता हूँ? अनुरोधित पृष्ठ तक पहुंचा नहीं जा सकता क्योंकि पृष्ठ के लिए संबंधित कॉन्फ़िगरेशन डेटा अमान्य त्रुटि है ह्यूवाइ फोन पर "संरक्षित ऐप्स" सेटिंग, और इसे कैसे प्रबंधित करें

इंटरफेस के लिए कार्यक्रम का क्या मतलब है?

मैं सबसे प्रोग्रामिंग संबंधित साइटों पर कथन को सुनता रहता हूं:

एक इंटरफेस के लिए कार्यक्रम और एक कार्यान्वयन के लिए नहीं

हालांकि मैं निहितार्थ समझ में नहीं आया?
उदाहरणों में मदद मिलेगी

संपादित करें: मुझे बहुत अच्छे उत्तर प्राप्त हुए हैं, फिर भी क्या आप इस विषय की बेहतर समझ के लिए कोड के कुछ स्निपेट के साथ इसे पूरक कर सकते हैं। धन्यवाद!

वेब के समाधान से एकत्रित समाधान "इंटरफेस के लिए कार्यक्रम का क्या मतलब है?"

आप शायद इस तरह से कुछ की तलाश कर रहे हैं:

public static void main(String... args) { // do this - declare the variable to be of type Set, which is an interface Set buddies = new HashSet(); // don't do this - you declare the variable to have a fixed type HashSet buddies2 = new HashSet(); } 

इसे पहली तरह से करना अच्छा क्यों माना जाता है? हम कहते हैं कि बाद में आप कहते हैं कि लिंक्डडेशशेट की कार्यक्षमता का लाभ उठाने के लिए एक अलग डेटा संरचना का उपयोग करने की आवश्यकता है, लिंक्ड एचशसेट कहते हैं। ऐसा कोड बदलना होगा जैसे:

 public static void main(String... args) { // do this - declare the variable to be of type Set, which is an interface Set buddies = new LinkedHashSet(); // <- change the constructor call // don't do this - you declare the variable to have a fixed type // this you have to change both the variable type and the constructor call // HashSet buddies2 = new HashSet(); // old version LinkedHashSet buddies2 = new LinkedHashSet(); } 

यह इतना बुरा नहीं लगता है, है ना? लेकिन क्या होगा अगर आप उसी तरह गेटर्स लिखते हैं?

 public HashSet getBuddies() { return buddies; } 

यह भी बदलना होगा!

 public LinkedHashSet getBuddies() { return buddies; } 

उम्मीद है कि आप देख सकते हैं, यहां तक ​​कि इस तरह के एक छोटे से कार्यक्रम के साथ भी, आपके पास चर के प्रकार को घोषित करने पर दूरगामी प्रभाव होता है। वस्तुएं आगे और पीछे चलती रहती हैं, इसलिए यह निश्चित रूप से कार्यक्रम को कोड को आसान बनाने में मदद करता है और बनाए रखता है यदि आप एक अंतरण के रूप में घोषित किए गए चर को भरोसा करते हैं, न कि इंटरफ़ेस के एक विशिष्ट कार्यान्वयन के रूप में (इस मामले में, सेट करें, लिंक किए गए HashSet या कुछ भी नहीं)। यह सिर्फ यह हो सकता है:

 public Set getBuddies() { return buddies; } 

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

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

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

प्रोग्रामर वापस कोडिंग के लिए चला गया। अपने आवेदन के दौरान छपी छपी एक्सएमएल से व्यावसायिक डेटा पढ़ने के लिए कोड था उन्होंने उन सभी स्निपेट को फिर से लिखा, उन्हें "if" शर्त से लपेटकर:

 if (dataType == "XML") { ... read a piece of XML data ... } else { .. query something from the SQL database ... } 

सॉफ़्टवेयर के नए चलन के साथ प्रस्तुत करते हुए, बॉस ने जवाब दिया: "यह बहुत अच्छा है, लेकिन क्या यह इस वेब सेवा से व्यवसाय डेटा पर भी रिपोर्ट कर सकता है?" उन सभी थकाऊ यादों को याद कर रहे हैं कि उन्हें फिर से लिखना होगा, तो प्रोग्रामर क्रोधित हो गए। "पहले एक्सएमएल, फिर एसक्यूएल, अब वेब सेवाओं! व्यापार डेटा का वास्तविक स्रोत क्या है?"

बॉस ने जवाब दिया: "कुछ भी जो इसे प्रदान कर सकता है"

उस पल में, प्रोग्रामर प्रबुद्ध था।

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

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

उदाहरण: मान लीजिए कि एक Screen वर्ग है जिस पर Draw(image) और Clear() तरीके हैं। प्रलेखन कहते हैं कि "ड्रॉ ​​विधि स्क्रीन पर निर्दिष्ट छवि खींचती है" और "स्पष्ट पद्धति स्क्रीन को साफ़ करती है"। यदि आप चित्रों को क्रमिक रूप से प्रदर्शित करना चाहते हैं, तो ऐसा करने का सही तरीका बार-बार कॉल Clear() बाद Clear() करें Clear() Draw() । यह इंटरफ़ेस को कोडिंग होगा। यदि आप क्रियान्वयन के लिए कोडिंग कर रहे हैं, तो आप Draw() विधि को कॉल करने की तरह कुछ कर सकते हैं क्योंकि आप Draw() के कार्यान्वयन को देखकर जानते हैं कि यह आंतरिक रूप से किसी भी ड्राइंग से पहले Clear() करता है। यह बुरा है क्योंकि अब आप कार्यान्वयन के विवरण पर निर्भर हैं, जिसे आप खुला इंटरफेस को देखने से नहीं जानते हैं।

मैं ओपी के सवाल में किसी और को वाक्यांश के इस व्याख्या को साझा करने के लिए उत्सुक हूं, या यदि मैं पूरी तरह से बेस से हूं …

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

उदाहरण के लिए, कहते हैं कि मॉड्यूल 1 एक विशिष्ट उपयोगकर्ता के लिए बैंक खाता जानकारी प्रदर्शित करने का ध्यान रखेगा, और मॉड्यूल 2 बैंक खाते की जानकारी को "जो कुछ भी" बैक-एंड का उपयोग किया जाता है उसे प्राप्त करेगा।

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

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

यह एक एपीआई का विचार है

एक इंटरफ़ेस विधियों को परिभाषित करता है कि ऑब्जेक्ट को प्रतिसाद देने के लिए प्रतिबद्ध है।

जब आप इंटरफ़ेस के लिए कोड करते हैं, तो आप अंतर्निहित ऑब्जेक्ट को बदल सकते हैं और आपका कोड अभी भी काम करेगा (क्योंकि आपका कोड अज्ञात है कि डब्लूएचओ ने काम किया है या काम कैसे किया जाता है) आप इस तरह लचीलेपन प्राप्त करते हैं

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

तो एक स्पष्ट उदाहरण डाल करने के लिए:

यदि आपको कई ऑब्जेक्ट रखने की ज़रूरत हो, तो आप ने वेक्टर का उपयोग करने का निर्णय लिया हो।

यदि आपको वेक्टर का पहला ऑब्जेक्ट एक्सेस करना है जिसे आप लिख सकते हैं:

  Vector items = new Vector(); // fill it Object first = items.firstElement(); 

अब तक सब ठीक है।

बाद में आपने फैसला किया कि "कुछ" कारणों से आपको कार्यान्वयन को बदलने की ज़रूरत है (हम कहते हैं कि वेक्टर अत्यधिक सिंक्रनाइज़ेशन के कारण बाधा उत्पन्न करता है)

आप का एहसास है कि आपको एक अर्रेइलास्ट इंस्टैड का उपयोग करना होगा

खैर, आपका कोड टूट जाएगा …

 ArrayList items = new ArrayList(); // fill it Object first = items.firstElement(); // compile time error. 

आप नहीं कर सकते यह पंक्ति और उन सभी पंक्ति जो पहले एलेमेंट () विधि का उपयोग करते हैं, वे टूटेंगे

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

  List items = new Vector(); // fill it Object first = items.get( 0 ); // 

इस रूप में आप वेक्टर की विधि प्राप्त करने के लिए कोडिंग नहीं कर रहे हैं, लेकिन सूची की विधि प्राप्त करने के लिए ।

इससे कोई फर्क नहीं पड़ता कि अंतर्निहित ऑब्जेक्ट विधि को कैसे निष्पादित करता है, जब तक यह "संग्रह का 0 वां तत्व प्राप्त" के अनुबंध का जवाब देता है

इस तरह आप बाद में इसे किसी अन्य कार्यान्वयन में बदल सकते हैं:

  List items = new ArrayList(); // Or LinkedList or any other who implements List // fill it Object first = items.get( 0 ); // Doesn't break 

यह नमूना सरल लग सकता है, लेकिन वह आधार है जिस पर ओओ तकनीक आधारित है (यहां तक ​​कि उन भाषा पर भी जो स्थैतिक रूप से पायथन, रुबी, स्मॉलटाक, ऑब्जेक्ट-सी इत्यादि की तरह नहीं टाइप की जाती है)

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

  statement.executeOracle9iSomething(); 

बनाम

 statement.executeOracle11gSomething(); 

जावा स्विंग के साथ कुछ ऐसा ही होता है

अतिरिक्त पढ़ने:

डिजाइन पैटर्न से डिजाइन सिद्धांत

प्रभावी जावा आइटम: अपने इंटरफेस द्वारा वस्तुओं को देखें

(इस पुस्तक को आप जीवन में सबसे अच्छी चीजों में से एक खरीदना – और जरूर पढ़ें -)

इसके मूल में, यह कथन निर्भरता के बारे में है अगर मैं अपने वर्ग Foo को कार्यान्वयन ( IBar बजाय Bar ) में IBar तो Foo अब Bar पर निर्भर है लेकिन अगर मैं अपने वर्ग Foo को एक इंटरफेस ( Bar बजाय Bar ) में IBar तो कार्यान्वयन अलग-अलग हो सकता है और Foo एक विशिष्ट क्रियान्वयन पर निर्भर नहीं रह सकता है। यह दृष्टिकोण एक लचीला, ढीली-युग्मित कोड आधार देता है जो अधिक आसानी से पुन: उपयोग किया जाता है, पुनर्रचना करता है और इकाई परीक्षण किया जाता है।

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

एक लाल 2×4 लेगो ब्लॉक लें और इसे नीले 2×4 लेगो ब्लॉक में संलग्न करें ताकि एक दूसरे के ऊपर बैठे। अब नीले ब्लॉक को हटा दें और इसे एक पीले 2×4 लेगो ब्लॉक से बदलें। नोटिस कि लाल ब्लॉक को बदलने की जरूरत नहीं है, हालांकि संलग्न ब्लॉक के "कार्यान्वयन" विविध।

अब लेगो "इंटरफ़ेस" साझा नहीं करता है जो किसी अन्य प्रकार के ब्लॉक मिल जाए इसे लाल 2×4 लेगो में संलग्न करने का प्रयास करें ऐसा करने के लिए, आपको लेगो या अन्य ब्लॉक को बदलने की आवश्यकता होगी, शायद कुछ प्लास्टिक को काटने या नया प्लास्टिक या गोंद जोड़ने से। ध्यान दें कि "कार्यान्वयन" को बदलकर आपको इसे या क्लाइंट को बदलने के लिए मजबूर किया जाता है

क्लाइंट या सर्वर को बदलने के बिना कार्यान्वयन करने में सक्षम होने के नाते – यह इंटरफेस के लिए प्रोग्राम का मतलब है।

देखो, मुझे नहीं पता था कि यह जावा के लिए था, और मेरा कोड सी # पर आधारित है, लेकिन मेरा मानना ​​है कि यह बिंदु प्रदान करता है

हर कार में दरवाजे हैं

लेकिन हर दरवाजा उसी तरह काम नहीं करता है, जैसे यूके में टैक्सी के दरवाजे पीछे हैं एक सार्वभौमिक तथ्य यह है कि वे "ओपन" और "बंद"

 interface IDoor { void Open(); void Close(); } class BackwardDoor : IDoor { public void Open() { // code to make the door open the "wrong way". } public void Close() { // code to make the door close properly. } } class RegularDoor : IDoor { public void Open() { // code to make the door open the "proper way" } public void Close() { // code to make the door close properly. } } class RedUkTaxiDoor : BackwardDoor { public Color Color { get { return Color.Red; } } } 

यदि आप एक कार के दरवाजे के मरम्मत करने वाले हैं, तो आप दरवाजे के दिखने की देखभाल नहीं करते हैं, या अगर यह एक ही रास्ता या दूसरी तरफ खुलता है तुम्हारी एकमात्र आवश्यकता यह है कि दरवाज़े दरवाजे की तरह कार्य करता है, जैसे कि ईदूर

 class DoorRepairer { public void Repair(IDoor door) { door.Open(); // Do stuff inside the car. door.Close(); } } 

रिपेयरर रेडयूकटैक्सीडूर, रेग्युलर डूर और बैकवर्ड डूर को नियंत्रित कर सकता है। और किसी अन्य प्रकार के दरवाजे, जैसे ट्रक के दरवाजे, लिमोसिन दरवाजे

 DoorRepairer repairer = new DoorRepairer(); repairer.Repair( new RegularDoor() ); repairer.Repair( new BackwardDoor() ); repairer.Repair( new RedUkTaxiDoor() ); 

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

 class ListAdder { public void PopulateWithSomething(IList list) { list.Add("one"); list.Add("two"); } } Stack stack = new Stack(); Queue queue = new Queue(); ListAdder la = new ListAdder() la.PopulateWithSomething(stack); la.PopulateWithSomething(queue); 

एलन हॉलब ने जावा वर्ल्ड के लिए 2003 में इस विषय पर एक लेख लिखा है कि क्यों बढ़ता है बुरा है उनका "इंटरफेस के लिए प्रोग्राम" विवरण पर ले जाता है, जैसा कि आप अपने शीर्षक से प्राप्त कर सकते हैं, यह है कि आपको खुशी से इंटरफेस लागू करना चाहिए, लेकिन बहुत कम उपयोग की गई extends को उप-वर्ग में उपयोग करना चाहिए। उन्होंने कहा, अन्य बातों के अलावा, जो नाजुक बेस-क्लास समस्या के रूप में जाना जाता है विकिपीडिया से:

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

अन्य उत्तरों के अतिरिक्त, मैं और अधिक जोड़ता हूं:

आप एक इंटरफ़ेस के लिए प्रोग्राम क्योंकि यह संभाल करने में आसान है। इंटरफ़ेस अंतर्निहित वर्ग के व्यवहार को समझाता है। इस तरह, क्लास एक ब्लैकबॉक्स है। आपका पूरा वास्तविक जीवन एक अंतरफलक के लिए प्रोग्रामिंग है जब आप एक टीवी, एक कार, एक स्टीरियो का उपयोग करते हैं, तो आप इसके इंटरफ़ेस पर कार्य कर रहे हैं, इसके कार्यान्वयन के विवरण पर नहीं, और आप मानते हैं कि यदि कार्यान्वयन में परिवर्तन (जैसे डीजल इंजन या गैस) अंतरफलक एक समान रहता है एक अंतरफलक के लिए प्रोग्रामिंग आपको अपने व्यवहार को संरक्षित करने की अनुमति देता है जब गैर-विघटनकारी विवरण बदलते हैं, ऑप्टिमाइज़ किए गए या तय होते हैं यह दस्तावेजीकरण, सीखने और प्रयोग करने का कार्य भी सरल करता है।

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

"एक इंटरफेस के लिए प्रोग्राम" अधिक लचीला हो सकता है

उदाहरण के लिए, हम क्लास प्रिंटर लिख रहे हैं जो प्रिंट सर्विस प्रदान करता है। वर्तमान में 2 वर्ग ( Cat और Dog ) को मुद्रित करने की आवश्यकता है। तो हम नीचे लिखे कोड लिखते हैं

 class Printer { public void PrintCat(Cat cat) { ... } public void PrintDog(Dog dog) { ... } ... } 

अगर कोई नया वर्ग Bird भी है तो इस प्रिंट सेवा की आवश्यकता है? हमें एक नया तरीका प्रिंटबर्ड जोड़ने के लिए Printer क्लास को बदलना होगा। असली मामले में, जब हम प्रिंटर क्लास विकसित करते हैं, तो हमें यह नहीं पता होगा कि इसका उपयोग कौन करेगा। तो Printer कैसे Printer ? एक इंटरफ़ेस के लिए प्रोग्राम मदद कर सकता है, कोड नीचे देखें

 class Printer { public void Print(Printable p) { Bitmap bitmap = p.GetBitmap(); // print bitmap ... } } 

इस नए प्रिंटर के साथ, सब कुछ तब तक प्रिंट किया जा सकता है जब तक यह इंटरफ़ेस Printable करने Printable । यहां विधि GetBitmap () सिर्फ एक उदाहरण है। महत्वपूर्ण बात यह है कि एक इंटरफ़ेस का पर्दाफाश न करें, कार्यान्वयन न हो।

आशा है कि यह उपयोगी है

मूल रूप से, इंटरफेस इंटरऑपेशन की सामान्य अवधारणाओं की थोड़ी अधिक ठोस प्रस्तुतियां हैं – वे विनिर्देश प्रदान करते हैं कि किसी विशेष फ़ंक्शन के लिए आप "प्लग इन" के सभी विकल्पों को किस प्रकार देखभाल कर सकते हैं, इसी तरह ऐसा करना चाहिए ताकि उनका उपयोग करने वाला कोड न हो एक विशेष विकल्प पर निर्भर

उदाहरण के लिए, कई डीबी पुस्तकालय इंटरफेस के रूप में कार्य करते हैं, जिसमें वे कई अलग-अलग वास्तविक डीबी (एमएसएसक्यूएल, मायएसक्यूएल, पोस्टग्रेएसक्यूएल, एसक्यूलाइट आदि) के साथ काम कर सकते हैं, जो कि डीबी लाइब्रेरी का इस्तेमाल सभी कोड को बदलने के लिए करता है।

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

एक अंतरफलक के लिए प्रोग्रामिंग करके, आप कम युग्मन / उच्च एकाग्रता सिद्धांत को लागू करने की अधिक संभावना रखते हैं। एक अंतरफलक के प्रोग्रामिंग करके, आप आसानी से उस अंतरफलक (विशिष्ट वर्ग) के कार्यान्वयन पर स्विच कर सकते हैं।

इसका अर्थ है कि आपके चर, गुण, पैरामीटर और रिटर्न के प्रकार के ठोस कार्यान्वयन के बजाय इंटरफ़ेस प्रकार होना चाहिए।

जिसका अर्थ है कि आप उदाहरण के लिए ArrayList Foo(ArrayList myList) के बजाय IEnumerable<T> Foo(IList mylist) ArrayList Foo(ArrayList myList) करते हैं।

ऑब्जेक्ट का निर्माण करते समय कार्यान्वयन का उपयोग करें:

 IList list = new ArrayList(); 

यदि आपने यह किया है, तो आप बाद में ऑब्जेक्ट प्रकार को बदल सकते हैं, आप बाद में ऐरेएलआईस्ट की बजाय लिंक्डलिस्ट का उपयोग करना चाहते हैं, यह हर जगह के बाद से कोई समस्या नहीं है और आप इसे केवल "आईएलआईटी"

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

ध्यान दें, एक अंतरफलक के रूप में एक अमूर्त वर्ग का उपयोग किया जा सकता है।

यहां छवि विवरण दर्ज करें

कार्यान्वयन के आधार पर प्रोग्रामिंग:

 Motorcycle motorcycle = new Motorcycle(); motorcycle.driveMoto(); 

इंटरफ़ेस के आधार पर प्रोग्रामिंग:

 Vehicle vehicle; vehicle = new Motorcycle(); // Note that DI -framework can do it for you vehicle.drive(); 

यह मूल रूप से आप इस तरह एक विधि / इंटरफ़ेस create( 'apple' ) : जिस तरह से create(param) create( 'apple' ) एक अमूर्त वर्ग / इंटरफ़ेस fruit से आता है जिसे बाद में ठोस वर्गों द्वारा लागू किया गया है। यह उप-क्लासिंग से अलग है आप एक ऐसे अनुबंध का निर्माण कर रहे हैं जो कक्षाओं को पूरा करना चाहिए। इससे युग्मन भी कम होता है और चीजें अधिक लचीला होती हैं जहां प्रत्येक कंक्रीट वर्ग इसे अलग तरीके से लागू करता है।

क्लाइंट कोड विशिष्ट प्रकार के वस्तुओं से अनजान रहता है और इन वस्तुओं को लागू करने वाले वर्गों से अनजान रहता है क्लाइंट कोड केवल इंटरफ़ेस create(param) बारे में जानता है और फल का उपयोग करने के लिए इसका उपयोग करता है यह कहने की तरह है, "मुझे परवाह नहीं है कि आप इसे कैसे प्राप्त कर सकते हैं या इसे बना सकते हैं, बस आप मुझे देना है।"

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