एक इंटरफेस के साथ बातचीत?

Question

जो मैंने पढ़ा है, ऐसा लगता है कि कोई इंटरफ़ेस से बातचीत कर सकता है?

उदाहरण के लिए। आइए कहें कि मुझे एक खाली विधि के साथ एक इंटरफ़ेस मिला है "खाने()"

फिर 2 उप-वर्ग इस इंटरफ़ेस को कार्यान्वित कर रहे हैं।

क्या मेरा नियंत्रक केवल इंटरफेस के साथ बातचीत कर सकता है और इसका खा सकता है() विधि?

इस लिंक strategy

Answer 1

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

interface Logger 
{ 
    const FOO = 1; 
    public function log($msg); 
} 

echo Logger::FOO; // 1 
Logger::log($msg); // Fatal error: Cannot call abstract method Logger::log() 
new Logger;  // Fatal error: Cannot instantiate interface Logger 

http://php.net/manual/en/language.oop5.interfaces.php

---

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

इन कक्षाओं पर विचार करें:

Class DbLog implements Logger 
{ 
    public function log($msg) { /* log $msg to database */ } 
} 

Class FileLog implements Logger 
{ 
    public function log($msg) { /* log $msg to file */ } 
} 

दोनों वर्गों Logger को लागू करने और उनके लिए एक विधि log($msg) करना होगा। आप मूल रूप से कह रहे हैं: "हे क्लास, यदि आप लॉगर बनना चाहते हैं, तो सुनिश्चित करें कि मैं आप पर लॉग() कॉल कर सकता हूं।"। अब आप अपने कोड में कहीं आप अगर यह FileLog, DbLog या किसी अन्य ठोस लॉगर हो जाता है परवाह नहीं है की तरह

class Foo 
{ 
    protected $logger; 
    public function __construct(Logger $logger) 
    { 
     $this->logger = $logger; 
     $this->logger->log('I can haz logger! Yay!'); 
    } 
} 

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

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

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