इंटरफेस

"नमस्कार, अमीगो! आज आप कुछ खोज करने जा रहे हैं। आज का विषय-ड्रम रोल, कृपया-इंटरफेस है। "

"हाँ। एक दिन इतना बढ़िया कि मैं नहाने के लिए घर जा रहा हूँ।"

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

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"दिलचस्प। लेकिन हमें इंटरफेस की आवश्यकता क्यों है? उनका उपयोग कब किया जाता है?"

"कक्षाओं पर इंटरफेस के दो मजबूत फायदे हैं:"

1) विधि कार्यान्वयन से "विधि परिभाषाओं" का पृथक्करण।

मैंने आपको पहले बताया था कि यदि आप अन्य वर्गों को अपनी कक्षा के तरीकों को कॉल करने की अनुमति देना चाहते हैं, तो आपको उन्हें चिह्नित करने की आवश्यकता हैpublic । यदि आप चाहते हैं कि कुछ विधियों को केवल अपनी कक्षा से ही बुलाया जाए, तो उन्हें चिह्नित किया जाना चाहिए private। दूसरे शब्दों में, हम कक्षा के तरीकों को दो श्रेणियों में विभाजित कर रहे हैं: «सभी के लिए» और «सिर्फ मेरे लिए»।

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

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

हम अपनी कक्षा को दो भागों में विभाजित करते हैं: एक इंटरफ़ेस और एक वर्ग जो इंटरफ़ेस को लागू करता है।

"तो क्या फायदा है?"

"एक ही इंटरफ़ेस को विभिन्न वर्गों द्वारा (विरासत में) लागू किया जा सकता है। और प्रत्येक वर्ग का अपना व्यवहार हो सकता है। जैसे ArrayList और LinkedList , सूची इंटरफ़ेस के दो अलग-अलग कार्यान्वयन हैं। "

इस प्रकार, हम न केवल विभिन्न कार्यान्वयनों को छिपा रहे हैं, बल्कि उन वर्गों को भी छिपा रहे हैं जिनमें कार्यान्वयन शामिल हैं (हम कोड में हर जगह इंटरफेस का उपयोग कर सकते हैं)। यह हमें बहुत लचीले ढंग से कुछ वस्तुओं को अन्य वस्तुओं के साथ बदलने देता है, जबकि प्रोग्राम चल रहा है, किसी भी वर्ग के ज्ञान के बिना किसी वस्तु के व्यवहार को बदलने के लिए इसका उपयोग कर रहा है।

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

2) एकाधिक वंशानुक्रम।

जावा में, प्रत्येक वर्ग में केवल एक मूल वर्ग हो सकता है। अन्य प्रोग्रामिंग भाषाओं में, कक्षाओं में अक्सर कई मूल वर्ग हो सकते हैं। यह बहुत सुविधाजनक है, लेकिन यह बहुत सारी समस्याएं भी पैदा करता है।

जावा एक समझौता प्रदान करता है:   आप कई वर्गों को इनहेरिट नहीं कर सकते, लेकिन आप कई इंटरफेस लागू कर सकते हैं। एक इंटरफ़ेस में कई मूल इंटरफ़ेस हो सकते हैं।  एक वर्ग कई इंटरफेस को लागू कर सकता है और केवल एक मूल वर्ग को प्राप्त कर सकता है।