जावा 8 इंटरफेस क्या हैं और आप उनका उपयोग कैसे करते हैं?

जावा में, एक इंटरफ़ेस एक सार वर्ग के समान ही कार्य करता है, जिसका अर्थ है कि किसी इंटरफ़ेस से कोई ऑब्जेक्ट कभी नहीं बनाया जा सकता है। इसके परिणामस्वरूप, एक इंटरफ़ेस में कंस्ट्रक्टर नहीं होते हैं, लेकिन इसमें विधियाँ होती हैं।

जावा 8 से पहले, एक इंटरफ़ेस उन संचालनों की रूपरेखा तैयार कर सकता था जो उसके कार्यान्वयन वर्ग करता है, लेकिन यह नहीं कि कार्यान्वयन वर्ग को इस ऑपरेशन को कैसे करना चाहिए (इस पर बाद में और अधिक)। अब जावा 8 के साथ, एक डेवलपर इंटरफेस के साथ दोनों काम कर सकता है।

ऐसा इसलिए है क्योंकि जावा 8 ने डिफ़ॉल्ट इंटरफ़ेस विधियों को पेश किया है। इसलिए डेवलपर्स के पास अब पारंपरिक अमूर्त विधियों के साथ-साथ एक इंटरफ़ेस के भीतर नई ठोस विधियों का उपयोग करने का विकल्प है। आओ हम इसे नज़दीक से देखें।

एक इंटरफ़ेस क्या है?

इससे पहले कि आप वास्तव में एक इंटरफ़ेस के उद्देश्य को समझ सकें और इसे प्रभावी ढंग से कैसे उपयोग कर सकें, आपको बहुरूपता को समझने की आवश्यकता होगी। बहुरूपता वस्तु-उन्मुख प्रोग्रामिंग की एक मुख्य अवधारणा है, जो एक डेवलपर को कक्षाओं के साथ सामान्यीकृत और विशिष्ट व्यवहार बनाने की अनुमति देता है (जो कुछ मामलों में, सीधे संबंधित नहीं हैं)।

बहुरूपता का मुख्य लाभ यह है कि यह कोड के पुन: उपयोग की सुविधा प्रदान करता है, जो आज के सॉफ्टवेयर विकास उद्योग में महत्वपूर्ण है।

सम्बंधित: बहुरूपता क्या है? और यह सीखने लायक क्यों है

तो बहुरूपता जावा इंटरफेस से कैसे संबंधित है? जावा में, एक इंटरफ़ेस उन वर्गों को अनुमति देता है जो पारंपरिक रूप से संबंधित नहीं होंगे, समान संचालन तक पहुंच रखने के लिए। अपने सरलतम रूप में, जावा इंटरफ़ेस एक टेम्प्लेट है जिसे इसे लागू करने वाले विभिन्न वर्गों द्वारा आसानी से उपयोग किया जा सकता है। ये कार्यान्वयन वर्ग तब एक विशिष्ट कार्य को पूरा करने के लिए एक इंटरफ़ेस की विधि को उसकी सामान्यीकृत स्थिति से अधिक विशिष्ट स्थिति में बदल सकते हैं।

जावा 8 इंटरफेस का उपयोग करने के क्या लाभ हैं?

जावा 8 इंटरफ़ेस का उपयोग करने का सबसे स्पष्ट लाभ इसकी नई ठोस विधि क्षमता है।

जावा 8 इंटरफेस का एक और स्वागत योग्य लाभ मौजूदा इंटरफेस में नए ठोस तरीकों को जोड़ने की क्षमता है, जो पहले से ही प्रोग्राम को तोड़े बिना लागू किया जा चुका है। जावा 8 से पहले, यदि आपके पास एक इंटरफ़ेस लागू करने वाला वर्ग था लेकिन इसके सभी तरीकों का उपयोग नहीं कर रहा था, तो उस वर्ग को सार के रूप में लेबल करना होगा। अन्यथा, कार्यक्रम टूट जाएगा।

आपको इंटरफ़ेस का उपयोग कब करना चाहिए?

कई मौजूदा प्रोग्राम जावा 8 इंटरफेस का संभावित रूप से उपयोग कर सकते हैं। एक इंटरफ़ेस का कार्य प्रोग्रामर के जीवन को आसान बनाना है। यद्यपि समान कार्यक्षमता को इंटरफेस के बिना प्राप्त किया जा सकता है, उनका उपयोग करने से आपके कार्यक्रम अधिक व्यवस्थित हो जाएंगे और आपकी विकास प्रक्रिया कम समय लेने वाली होगी।

यदि आप वंशानुक्रम से परिचित हैं, तो आपको पता होना चाहिए कि यह वस्तु-उन्मुख प्रोग्रामिंग की एक मूल अवधारणा भी है जो सामान्यीकरण की सुविधा प्रदान करती है। विरासत के साथ, समान वर्गों को माता-पिता-बाल संबंधों में बांटा गया है।

बहुरूपता (जो प्रोग्रामिंग व्यवहार है जो एक इंटरफ़ेस प्रदर्शित करता है) के साथ, जिन वर्गों में आम तौर पर समान विधियों तक पहुंच नहीं होती है (माता-पिता-बाल संबंधों की कमी के कारण), अब बहुरूपी रूप से संसाधित किया जा सकता है।

एक इंटरफ़ेस का उपयोग करने का एक व्यावहारिक उदाहरण एक सॉफ्टवेयर संगठन के लेखा विभाग के भीतर है। कर्मचारी की भुगतान पर्ची और ग्राहक का चालान बनाते समय यह विभाग समान तरीकों (या संचालन) के एक सेट का संचालन करेगा।

ये दो वर्ग हैं जो परंपरागत रूप से संबंधित नहीं होंगे, लेकिन अब वे जावा 8 इंटरफेस के लिए कुछ समान संचालन का उपयोग कर सकते हैं।

जावा में एक इंटरफ़ेस बनाना

उपरोक्त लेखा विभाग परिदृश्य का उपयोग करके, आप एक इंटरफ़ेस बना सकते हैं जो भुगतान संचालन से संबंधित है। इस इंटरफ़ेस का उद्देश्य भुगतान रिपोर्ट (चालान, भुगतान पर्ची और अन्य व्यय के रूप में) के निर्माण में सहायता करना है।

जावा इंटरफ़ेस उदाहरण बनाना

 //Java interface
 public interface Payable {
 //abstract method public void paymentAmount();
 }

उपरोक्त कोड एक साधारण जावा इंटरफ़ेस उत्पन्न करता है। इंटरफ़ेस कीवर्ड इंगित करता है कि Payable एक इंटरफ़ेस है और PaymentAmount () विधि एक अमूर्त विधि है क्योंकि यह लागू नहीं है।

देय इंटरफ़ेस उदाहरण लागू करना

 public class Employee implements Payable {
 //attributes
 private String name; private String position;
 //primary constructor
 public Employee (String name, String position) {
 this.name = name; this.position = position;
 }
 //payLevel method - takes an employee's position and returns their pay
 public double payLevel(String position) {
 position.toLowerCase();
 if (position == "junior" ) {
 return 10.00;
 }
 if(position == "mid-level") {
 return 20.0;
 }
 if(position == "senior") {
 return 30.00;
 }
 return 0 ;
 }
 @Override public void paymentAmount() {
 //passes the position attribute provided by the user to the payLevel() method above
 // store the return from the function call to a double variable called pay
 //and print the relevant data to the console
 double pay = payLevel(position);
 System.out.println(name + " pay for this month is: " + pay);
 }
 }

किसी कक्षा में एक इंटरफ़ेस का उपयोग करने के लिए, आपको पहले उस इंटरफ़ेस को लागू करने वाले कीवर्ड का उपयोग करके लागू करना होगा , जैसा कि आप ऊपर दिए गए कोड में देख सकते हैं। एक नया इंटरफ़ेस लागू करने के बाद, आपको @Override कीवर्ड का उपयोग करके इंटरफ़ेस में सभी सार विधियों के लिए ठोस तरीके बनाने चाहिए।

संबंधित: जावा में बहुरूपता: विधियों को अधिभार या ओवरराइड कैसे करें

कार्यक्रम का निष्पादन उदाहरण

 public class Main {
 public static void main(String[] args) {
 //Create a new employee pay report
 Payable JanesPay = new Employee ("Jane Doe", "mid-level");
 //calculate the employee's pay
 JanesPay.paymentAmount();
 }
 }

ऊपर दिया गया प्रोग्राम देय इंटरफ़ेस का उपयोग करने वाली एक नई पेस्लिप उत्पन्न करने के लिए कर्मचारी वर्ग का उपयोग करता है। इंटरफ़ेस से ऑब्जेक्ट नहीं बनाया जा सकता है, लेकिन इंटरफ़ेस का उपयोग करके ऑब्जेक्ट को घोषित किया जा सकता है, जैसा कि आप ऊपर दिए गए कोड में देख सकते हैं।

जेन की वेतन वस्तु दो विशेषताओं-एक कर्मचारी का नाम और कंपनी में कर्मचारी की स्थिति का उपयोग करके बनाई गई है। कर्मचारी वर्ग में केवल एक प्राथमिक कंस्ट्रक्टर होता है, इसलिए, बनाए गए प्रत्येक नए कर्मचारी ऑब्जेक्ट में दो स्ट्रिंग विशेषताएँ होनी चाहिए।

जेन के पे ऑब्जेक्ट का उपयोग करते हुए, प्रोग्राम कर्मचारी वर्ग में भुगतान राशि () विधि को कॉल करता है, जो कंसोल में निम्न आउटपुट उत्पन्न करता है:

 Jane Doe pay for this month is: 20.0

ग्राहक उदाहरण के साथ देय इंटरफ़ेस को लागू करना

 public class Customer implements Payable{
 private String customerName;
 private String projectType;
 public Customer(String customerName, String projectType) {
 this.customerName = customerName;
 this.projectType = projectType;
 }
 public double customerInvoice(String projectType) {
 projectType.toLowerCase();
 if (projectType == "small" ) {
 return 10.00;
 }
 if(projectType == "medium") {
 return 20.0;
 }
 if(projectType == "large") {
 return 30.00;
 }
 return 0 ;
 }
 @Override public void paymentAmount() {
 double total = customerInvoice(projectType);
 System.out.println(customerName + " total charge for services provided is: " + total);
 }
 }

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

अब, वही ऑपरेशन जो कर्मचारी वर्ग की किसी वस्तु पर किए गए थे, ग्राहक वर्ग की किसी वस्तु पर भी किए जा सकते हैं।

ग्राहक वस्तु उदाहरण बनाना

 public class Main {
 public static void main(String[] args) {
 //Create a new customer invoice report
 Payable PaulsInvoice = new Customer("Paul Smith", "large");
 //calculate the customer's pay
 PaulsInvoice.paymentAmount();
 }
 }

उपरोक्त कोड कंसोल में निम्न आउटपुट उत्पन्न करता है:

 Paul Smith total charge for services provided is: 30.0

क्योंकि इंटरफ़ेस एक जावा 8 इंटरफ़ेस है, आप कोड को तोड़े बिना इसमें डिफ़ॉल्ट तरीके जोड़ सकते हैं, जैसा कि आप नीचे दिए गए उदाहरण में देख सकते हैं।

जावा 8 इंटरफ़ेस उदाहरण अपडेट करना

 //Java interface
 public interface Payable {
 //abstract method
 public abstract void paymentAmount();
 //concrete method
 public default void companyName() {
 System.out.println("Software Company");
 }
 }

जावा 8 से पहले, उपरोक्त कोड में आपके इंटरफ़ेस में ठोस विधि जोड़ने से इंटरफ़ेस टूट जाएगा। ऐसा इसलिए है क्योंकि जावा 8 से पहले के इंटरफेस में ठोस तरीके नहीं हो सकते थे। हालाँकि, यदि विधि सार थी, तो इंटरफ़ेस अप्रभावित रहेगा। लेकिन नई विधि जोड़ने से पहले इसे लागू करने वाली कक्षाएं टूट जाएंगी।

अब जावा 8 के कारण, इंटरफ़ेस में ठोस तरीके जोड़ने से पहले से लागू की गई कक्षाएं नहीं टूटेंगी। इसलिए, इस खाता प्रबंधन उदाहरण में दो कार्यान्वयन वर्गों में से किसी एक से बनाई गई वस्तुएं अपने मौजूदा कोड को बदले बिना companyName() पद्धति का उपयोग कर सकती हैं।

जावा 8 इंटरफ़ेस डिफ़ॉल्ट विधि उदाहरण का

 public class Main {
 public static void main(String[] args) {
 //Create a new employee pay report
 Payable JanesPay = new Employee("Jane Doe", "mid-level");
 //call the default method from the interface
 JanesPay.companyName();
 //calculate the employee's pay
 JanesPay.paymentAmount();
 }
 }

उपरोक्त कोड कंसोल में निम्नलिखित का उत्पादन करेगा:

 Software Company
 Jane Doe pay for this month is: 20.0

पुन: प्रयोज्य कोड बनाने के लिए सामान्यीकरण का

अब आप जावा 8 इंटरफेस की मदद से उन कक्षाओं के लिए समान संचालन का उपयोग कर सकते हैं जो परंपरागत रूप से संबंधित नहीं हैं। आपके पास अपने इंटरफेस में ठोस और अमूर्त दोनों तरीकों का उपयोग करने का विकल्प और ज्ञान भी है।

लेकिन परंपरागत रूप से संबंधित कक्षाओं के लिए, आप सीख सकते हैं कि विरासत के साथ कोड का पुन: उपयोग कैसे करें।