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

Java ची प्रत्येक नवीन आवृत्ती मागील आवृत्तीपेक्षा वेगळी असते. enumsआम्ही कव्हर केलेल्या सामग्रीमधून अशा बदलाचे उदाहरण म्हणून, भाषा Java 5 पूर्वी नव्हती . इतकेच, Java 8 हे Java 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 go() {
       System.out.println("Gas!");
   }

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


public class F1Car implements Car {
   @Override
   public void go() {
       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 go() {
       System.out.println("This car accelerates differently!");
   }

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

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

public class Waterfowl {
}

public class FlyingBird {
}

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

public class Duck implements FlyingBird, Waterfowl {

   // Methods of both interfaces combine easily into one class
  
   @Override
   public void fly() {
       System.out.println("Flying!");
   }

   @Override
   public void swim() {

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

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