इंटरफेसचे सार

1. क्षमता

इंटरफेसचे फायदे आणि ते कुठे वापरायचे हे अधिक चांगल्या प्रकारे समजून घेण्यासाठी आपल्याला आणखी काही अमूर्त गोष्टींबद्दल बोलणे आवश्यक आहे.

वर्ग सहसा विशिष्ट वस्तूचे मॉडेल बनवतो. इंटरफेस वस्तूंशी कमी आणि त्यांच्या क्षमता किंवा भूमिकांशी जास्त जुळतो.

उदाहरणार्थ, कार, बाईक, मोटारसायकल आणि चाके यांसारख्या गोष्टी वर्ग आणि वस्तू म्हणून उत्तम प्रकारे दर्शवल्या जातात. परंतु त्यांच्या क्षमता - जसे की "मी स्वार होऊ शकतो", "मी लोकांची वाहतूक करू शकतो", "मी उभे राहू शकतो" - इंटरफेस म्हणून अधिक चांगल्या प्रकारे सादर केले जातात. येथे काही उदाहरणे आहेत:

interface CanMove
{
   void move(String newLocation);
}

interface Rideable
{
   void ride(Passenger passenger);
}

interface CanTransport
{
   void addStuff(Object stuff);
   Object removeStuff();
}

class Wheel implements CanMove
{
   ...
}

class Car implements CanMove, Rideable, CanTransport
{
   ...
}

class Skateboard implements CanMove, Rideable
{
   ...
}

2. भूमिका

इंटरफेस प्रोग्रामरचे जीवन मोठ्या प्रमाणात सुलभ करतात. बर्‍याचदा, प्रोग्राममध्ये हजारो ऑब्जेक्ट्स, शेकडो वर्ग असतात, परंतु फक्त दोन डझन इंटरफेस असतात , म्हणजे भूमिका . काही भूमिका आहेत, परंतु त्यांना (वर्ग) एकत्र करण्याचे अनेक मार्ग आहेत.

संपूर्ण मुद्दा असा आहे की प्रत्येक वर्गाशी संवाद साधण्यासाठी तुम्हाला प्रत्येक वर्गात कोड लिहिण्याची गरज नाही. तुम्हाला फक्त त्यांच्या भूमिकांशी (इंटरफेस) संवाद साधण्याची गरज आहे.

कल्पना करा की तुम्ही पाळीव प्राणी प्रशिक्षक आहात. तुम्ही काम करत असलेल्या प्रत्येक पाळीव प्राण्यांमध्ये अनेक भिन्न क्षमता असू शकतात. कोणाचे पाळीव प्राणी जास्त आवाज करू शकतात या संदर्भात तुम्ही तुमच्या शेजाऱ्याशी मैत्रीपूर्ण वाद घालता. या प्रकरणाचा निपटारा करण्यासाठी, तुम्ही फक्त "बोलू" शकतील अशा सर्व पाळीव प्राण्यांची रांग लावा आणि तुम्ही त्यांना आज्ञा द्या: बोला!

ते कोणत्या प्रकारचे प्राणी आहेत किंवा त्यांच्याकडे कोणत्या इतर क्षमता आहेत याची आपल्याला पर्वा नाही. जरी ते ट्रिपल बॅक सॉमरसॉल्ट करू शकतात. या विशिष्ट क्षणी, आपल्याला फक्त त्यांच्या मोठ्याने बोलण्याच्या क्षमतेमध्ये स्वारस्य आहे. कोडमध्ये ते कसे दिसेल ते येथे आहे:

interface CanSpeak
{
   void speak();
}

class Cat implements CanSpeak
{
   void speak()
   {
      println("MEOW");
   }
}

class Dog implements CanSpeak
{
   void speak()
   {
      println("WOOF");
   }
}

class Fish
{
   ...
}

public static void main(String[] args)
{
   // Add all the animals to the list
   ArrayList pets = new ArrayList();
   pets.add(new Cat());
   pets.add(new Dog());
   pets.add(new Fish());

   // If the ability exists, then make a sound
   for(Object pet: pets)
   {
      if (pet instanceof CanSpeak)
      {
         CanSpeak loudmouth = (CanSpeak) pet;
         loudmouth.speak();
      }
   }
}

जेव्हा तुमच्या प्रोग्राममधील वर्गांची संख्या हजारोपर्यंत पोहोचते तेव्हा तुम्ही इंटरफेसशिवाय जगू शकणार नाही. हजारो वर्गांच्या परस्परसंवादाचे वर्णन करण्याऐवजी, काही डझन इंटरफेसच्या परस्परसंवादाचे वर्णन करणे पुरेसे आहे - हे जीवन मोठ्या प्रमाणात सुलभ करते.

आणि पॉलीमॉर्फिझमसह एकत्रित केल्यावर, हा दृष्टीकोन सामान्यतः एक स्मॅशिंग यश आहे.

3. defaultइंटरफेस पद्धतींची अंमलबजावणी

अ‍ॅबस्ट्रॅक्ट क्लासेसमध्ये व्हेरिएबल्स आणि पद्धतींची अंमलबजावणी असू शकते, परंतु त्यांना एकाधिक वारसा असू शकत नाही. इंटरफेसमध्ये व्हेरिएबल्स किंवा पद्धतींची अंमलबजावणी असू शकत नाही, परंतु त्यात एकाधिक वारसा असू शकतो.

परिस्थिती खालील सारणीमध्ये व्यक्त केली आहे:

तर, काही प्रोग्रामरना इंटरफेसमध्ये पद्धत लागू करण्याची क्षमता असायला हवी होती. परंतु पद्धत अंमलबजावणी जोडण्याची क्षमता असण्याचा अर्थ असा नाही की एक नेहमी जोडली जाईल. हवे असल्यास जोडा. किंवा आपण नाही तर, नंतर करू नका.

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

येथे एक अद्यतनित सारणी आहे (JDK 8 आणि त्यावरील साठी):

आता अमूर्त वर्गांसाठी तसेच इंटरफेससाठी, तुम्ही अंमलबजावणीसह किंवा त्याशिवाय पद्धती घोषित करू शकता. आणि ही चांगली बातमी आहे!

अमूर्त वर्गांमध्ये, अंमलबजावणीशिवाय पद्धती कीवर्डच्या आधी असणे आवश्यक आहे abstract. अंमलबजावणीसह पद्धतींपूर्वी तुम्हाला काहीही जोडण्याची आवश्यकता नाही. इंटरफेसमध्ये, उलट सत्य आहे. जर एखाद्या पद्धतीची अंमलबजावणी नसेल, तर काहीही जोडले जाऊ नये. परंतु जर अंमलबजावणी असेल तर defaultकीवर्ड जोडणे आवश्यक आहे.

साधेपणासाठी, आम्ही खालील छोट्या तक्त्यामध्ये ही माहिती सादर करतो:

समस्या

पद्धती असलेल्या इंटरफेसचा वापर केल्याने मोठ्या वर्गाची पदानुक्रमे मोठ्या प्रमाणात सुलभ होऊ शकतात. उदाहरणार्थ, अमूर्त InputStreamआणि OutputStreamवर्ग इंटरफेस म्हणून घोषित केले जाऊ शकतात! हे आम्हाला ते अधिक वेळा आणि अधिक सोयीस्करपणे वापरू देते.

पण जगात आधीच लाखो (कोट्यवधी?) Java वर्ग आहेत. आणि जर तुम्ही मानक लायब्ररी बदलण्यास सुरुवात केली, तर तुम्ही कदाचित काहीतरी खंडित करू शकता. सर्वकाही आवडले! 😛

विद्यमान प्रोग्राम आणि लायब्ररी चुकून खंडित होऊ नयेत म्हणून, इंटरफेसमधील पद्धती अंमलबजावणीला सर्वात कमी वारसा प्राधान्य असेल असे ठरवले गेले .

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

interface Pet
{
   default void meow()
   {
      System.out.println("Meow");
   }
}

interface Cat extends Pet
{
   void meow(); // Here we override the default implementation by omitting an implementation
}

class Tom implements Cat
{
}

कोड संकलित होणार नाही कारण Tomवर्ग पद्धत लागू करत नाही meow().