इंटरफेसमधील डीफॉल्ट पद्धती

Java ची प्रत्येक नवीन आवृत्ती आधी आलेल्या आवृत्तीपेक्षा वेगळी आहे. आम्ही कव्हर केलेल्या साहित्यातील बदलांचे एक उदाहरण येथे आहे: Java 5 पूर्वी, भाषेत s नव्हते enum. त्याचप्रमाणे, Java 8 Java 7 पेक्षा स्पष्टपणे वेगळे आहे. आमचे बहुतेक धडे भाषेच्या 7 व्या आवृत्तीसाठी लिहिलेले आहेत, परंतु अर्थातच आम्ही महत्त्वपूर्ण नवकल्पनांकडे दुर्लक्ष करणार नाही. आम्ही या धड्यात इंटरफेसबद्दल आधीच बोलत असल्यामुळे, आम्ही एका अपडेटचा विचार करू - इंटरफेसमधील डीफॉल्ट पद्धती . तुम्हाला आधीच माहित आहे की इंटरफेस वर्तनाची अंमलबजावणी करत नाही . त्याचे कार्य हे वर्तनाचे वर्णन करणे आहे जे ते लागू करणार्‍या सर्व वस्तूंमध्ये असणे आवश्यक आहे. परंतु विकासकांना वारंवार अशा परिस्थितींचा सामना करावा लागतो जेथे पद्धतीची अंमलबजावणी सर्व वर्गांमध्ये सारखीच असते. चला आमच्या जुन्या कारचे उदाहरण पाहू:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

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

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

आता gas()आणि brake()पद्धती, ज्या सर्व कारसाठी समान होत्या, इंटरफेसमध्ये हलविल्या गेल्या आहेत. पुनरावृत्ती कोड आवश्यक नाही. इतकेच काय, प्रत्येक वर्गात पद्धती उपलब्ध आहेत!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

पद्धतीसह 100 वर्ग असतील gas(), परंतु त्यापैकी फक्त 99 वर्ग समान असतील तर? ते सर्व काही नष्ट करते आणि या परिस्थितीसाठी डीफॉल्ट पद्धत अयोग्य बनवते? अर्थात, नाही :) इंटरफेसमधील डीफॉल्ट पद्धती सामान्य पद्धतींप्रमाणेच ओव्हरराइड केल्या जाऊ शकतात.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

इतर सर्व 99 प्रकारच्या कार डीफॉल्ट पद्धत लागू करतील आणिUnusualCarवर्ग, जो अपवाद आहे, एकूण चित्र खराब करणार नाही आणि शांतपणे स्वतःचे वर्तन परिभाषित करेल. इंटरफेसचा एकाधिक वारसा. तुम्हाला आधीच माहिती आहे, Java एकाधिक वारसा समर्थन देत नाही. याची अनेक कारणे आहेत. आम्ही त्यांना एका वेगळ्या धड्यात तपशीलवार पाहू. इतर भाषा, जसे की C++, त्यास समर्थन देतात. एकाधिक वारसाशिवाय, एक गंभीर समस्या उद्भवते: एका वस्तूमध्ये अनेक भिन्न वैशिष्ट्ये आणि 'वर्तणूक' असू शकतात. हे जीवनातील एक उदाहरण आहे: आपण आपल्या पालकांसाठी मुले आहोत, आपल्या शिक्षकांसाठी विद्यार्थी आहोत आणि डॉक्टरांसाठी रुग्ण आहोत. जीवनात, आपण वेगवेगळ्या भूमिका घेतो आणि त्यानुसार, वेगळ्या पद्धतीने वागतो: अर्थातच, आपण आपल्या जवळच्या मित्रांशी बोलतो तसे शिक्षकांशी बोलत नाही. चला हे कोडमध्ये भाषांतरित करण्याचा प्रयत्न करूया. कल्पना करा की आमच्याकडे दोन वर्ग आहेत: तलाव आणि पक्षीगृह. तलावासाठी, आपल्याला पाण्याची मुरळी आवश्यक आहे; पक्षीपालनासाठी, आम्हाला उडणारे पक्षी हवे आहेत. हे करण्यासाठी, आम्ही दोन बेस क्लास तयार केले आहेत:FlyingBirdआणि Waterfowl_

public class Waterfowl {
}

public class FlyingBird {
}

त्यानुसार, आम्ही पक्षी ज्यांचे वर्ग वारशाने FlyingBirdपक्षीगृहात पाठवू आणि ज्या पक्ष्यांना वारसा आहे त्यांना आम्ही Waterfowlतलावात पाठवू. हे सर्व खूप सोपे दिसते. पण आम्ही बदक कुठे पाठवू? तो पोहतो आणि उडतो. आणि आमच्याकडे एकापेक्षा जास्त वारसा नाही. सुदैवाने, Java इंटरफेसच्या एकाधिक अंमलबजावणीस समर्थन देते. जरी एक वर्ग अनेक पालकांना वारसा देऊ शकत नसला तरी तो अनेक इंटरफेस सहजपणे लागू करू शकतो! आमचे बदक उडणारे पक्षी आणि पाणपक्षी दोन्ही असू शकतात :) इच्छित परिणाम साध्य करण्यासाठी आम्हाला फक्त क्लासेसऐवजी इंटरफेस बनवणे FlyingBirdआणि इंटरफेस करणे आवश्यक आहे.Waterfowl

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

त्यानुसार, आमचा प्रोग्राम वर्गांची लवचिकता राखून ठेवतो आणि, डीफॉल्ट पद्धतींच्या संयोजनात, वस्तूंचे वर्तन परिभाषित करण्याची आमची क्षमता जवळजवळ अमर्यादित होते! :)