इंटरफेस

"हॅलो, अमिगो! आज तुम्ही काही शोध लावणार आहात. आजचा विषय-ड्रम रोल, कृपया-इंटरफेस आहे. "

"हो. एक दिवस इतका छान आहे की मी आंघोळीसाठी घरी जात आहे."

" इंटरफेस हे अ‍ॅबस्ट्रॅक्शन आणि पॉलीमॉर्फिझमचे मूल आहे. इंटरफेस हा एका अमूर्त वर्गासारखा असतो जिथे सर्व पद्धती अमूर्त असतात. ते वर्गाप्रमाणेच घोषित केले जाते, परंतु कीवर्डसह. interfaceयेथे काही उदाहरणे आहेत:"

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

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

abstract class 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) एकाधिक वारसा.

Java मध्ये, प्रत्येक वर्गात फक्त एक पालक वर्ग असू शकतो. इतर प्रोग्रामिंग भाषांमध्ये, वर्गांमध्ये अनेक पालक वर्ग असू शकतात. हे खूप सोयीस्कर आहे, परंतु यामुळे बर्याच समस्या देखील निर्माण होतात.

जावा एक तडजोड ऑफर करते:   तुम्ही एकाधिक क्लासेस इनहेरिट करू शकत नाही, परंतु तुम्ही अनेक इंटरफेस लागू करू शकता. इंटरफेसमध्ये अनेक पालक इंटरफेस असू शकतात.  एक वर्ग एकाधिक इंटरफेस लागू करू शकतो आणि फक्त एक पालक वर्ग वारसा मिळवू शकतो.