दिलचस्प पोस्ट
कैसे मैक पर .bash_profile को पुनर्स्थापित करें? मेरे यूनिक्स टर्मिनल में से कोई भी काम नहीं कर रहा है URLConnection या HTTPClient: जो बेहतर कार्यक्षमता और अधिक दक्षता प्रदान करता है? ग्रिडलेआउट (GridView नहीं) सभी बच्चों को समान रूप से कैसे फैलाना जावास्क्रिप्ट को स्ट्रिंग से नंबर मिलता है 'ऐप' एंड्रॉइड एक्सएमएल नामस्थान क्या है? जावा: System.out.println और System.err.println क्रम से बाहर एक datetime2 डेटा प्रकार का डेट डेटा डेटा प्रकार के रूपांतरण के परिणामस्वरूप एक आउट-ऑफ-रेंज वैल्यू हुआ कैसे सी में structs की एक सरणी सॉर्ट करने के लिए? सहायता लाइब्रेरी से एक्शन बार को प्राथमिकता में कैसे जोड़ें? मैं एक PHP घातक त्रुटि कैसे प्राप्त करूं? पायथन में ओएससिस्टम () का रिटर्न वैल्यू क्या है? सी में स्थिर चर का आरम्भिकरण कैसे हेक्स स्ट्रिंग को जावा स्ट्रिंग में परिवर्तित करने के लिए एनएसडीटा को बेस 64 में परिवर्तित करना जावा में शून्य क्यों मुख्य () है?

मुझे अंतरफलक और एक सार वर्ग के बीच अंतर कैसे समझाया जाना चाहिए?

मेरे एक साक्षात्कार में, मुझे इंटरफ़ेस और एब्स्ट्रक्ट क्लास के बीच के अंतर को समझाने के लिए कहा गया है।

यहां मेरी प्रतिक्रिया है:

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

एक जावा इंटरफ़ेस में घोषित वेरिएबल डिफ़ॉल्ट रूप से अंतिम हैं एक सार वर्ग में गैर-अंतिम चर शामिल हो सकते हैं।

जावा अंतरफलक के सदस्य डिफ़ॉल्ट रूप से सार्वजनिक हैं जावा सारणी वर्ग में निजी सदस्यों, संरक्षित, आदि जैसे वर्ग के सदस्यों का सामान्य स्वाद हो सकता है।

जावा "इंटरफ़ेस" का प्रयोग करके एक जावा इंटरफेस लागू किया जाना चाहिए; कीवर्ड "विस्तार" का उपयोग करके एक जावा सारणी वर्ग को बढ़ाया जाना चाहिए

एक इंटरफ़ेस एक और जावा अंतरफलक का विस्तार कर सकता है, एक अमूर्त वर्ग एक और जावा वर्ग का विस्तार कर सकता है और कई जावा इंटरफेस लागू कर सकता है।

जावा क्लास कई इंटरफेस लागू कर सकता है लेकिन यह केवल एक सार क्लास का विस्तार कर सकता है।

हालांकि, साक्षात्कारकर्ता संतुष्ट नहीं था, और मुझे बताया कि यह विवरण " बकवास ज्ञान " का प्रतिनिधित्व करता है

उन्होंने मुझसे अधिक व्यावहारिक जवाब देने के लिए कहा, समझाते हुए कि मैं व्यावहारिक उदाहरणों का उपयोग करते हुए एक अंतरफलक पर एक अमूर्त वर्ग चुनना चाहता हूं

मुझसे कहां गलती हो गई?

Solutions Collecting From Web of "मुझे अंतरफलक और एक सार वर्ग के बीच अंतर कैसे समझाया जाना चाहिए?"

मैं आपको पहले एक उदाहरण दूंगा:

public interface LoginAuth{ public String encryptPassword(String pass); public void checkDBforUser(); } 

अब मान लीजिए आपके पास आपके आवेदन में 3 डाटाबेस हैं I तब उस डेटाबेस के लिए हर कार्यान्वयन को उपरोक्त 2 तरीकों को परिभाषित करने की आवश्यकता होती है:

 public class DBMySQL implements LoginAuth{ // Needs to implement both methods } public class DBOracle implements LoginAuth{ // Needs to implement both methods } public class DBAbc implements LoginAuth{ // Needs to implement both methods } 

लेकिन क्या अगर एन्क्रिप्ट पासवर्ड () डेटाबेस निर्भर नहीं है, और यह प्रत्येक वर्ग के लिए समान है? तो ऊपर एक अच्छा दृष्टिकोण नहीं होगा

इसके बजाय, इस दृष्टिकोण पर विचार करें:

 public abstract class LoginAuth{ public String encryptPassword(String pass){ // Implement the same default behavior here // that is shared by all subclasses. } // Each subclass needs to provide their own implementation of this only: public abstract void checkDBforUser(); } 

अब प्रत्येक बच्चे की कक्षा में, हमें केवल एक विधि को लागू करने की आवश्यकता है – यह तरीका डेटाबेस निर्भर है।

मैंने अपनी पूरी कोशिश की और उम्मीद है कि यह आपके संदेह को साफ करेगा

इस दुनिया में कुछ भी सही नहीं है वे अधिक व्यावहारिक दृष्टिकोण की अपेक्षा कर रहे थे।

लेकिन आपके स्पष्टीकरण के बाद आप थोड़ा अलग दृष्टिकोण के साथ इन पंक्तियों को जोड़ सकते हैं

  1. इंटरफेस नियम हैं (नियम हैं क्योंकि आपको उनको कार्यान्वयन देना चाहिए जिन्हें आप अनदेखा नहीं कर सकते हैं या न से बच सकते हैं, ताकि उन्हें नियमों के रूप में लगाया जा सके) जो सॉफ्टवेयर डेवलपमेंट में विभिन्न टीमों के बीच एक सामान्य समझ दस्तावेज़ के रूप में काम करता है।

  2. इंटरफेस यह विचार देते हैं कि क्या किया जाना है, लेकिन यह नहीं कि यह कैसे किया जाएगा। इसलिए कार्यान्वयन पूरी तरह से दिए गए नियमों का पालन करके डेवलपर पर निर्भर करता है (तरीकों का अर्थ दिया हस्ताक्षर)

  3. सार वर्गों में स्पष्ट घोषणा, ठोस कार्यान्वयन, या दोनों हो सकते हैं।

  4. अमूर्त घोषणाओं का पालन करने के नियमों की तरह हैं और ठोस कार्यान्वयन दिशानिर्देशों की तरह हैं (आप इसका प्रयोग कर सकते हैं या आप इसे ओवरराइड करके इसे अनदेखा कर सकते हैं और अपना खुद का कार्यान्वयन कर सकते हैं)।

  5. इसके अतिरिक्त, एक ही हस्ताक्षर वाले तरीकों से अलग-अलग संदर्भों में व्यवहार को बदल सकता है इंटरफ़ेस घोषणाओं के रूप में अलग-अलग संदर्भों में तदनुसार लागू करने के नियमों के रूप में प्रदान किए जाते हैं।

आपने उपयोग और क्रियान्वयन में व्यावहारिक अंतर का अच्छा सारांश दिया है लेकिन अर्थ में अंतर के बारे में कुछ नहीं कहा है।

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

एक अमूर्त वर्ग अलग-अलग उप-वर्गों का एक आधार होता है जो व्यवहार को साझा करता है जिसे बार-बार बनाया जाना आवश्यक नहीं है। उप-वर्गों को व्यवहार पूरा करना होगा और पूर्वनिर्धारित व्यवहार को ओवरराइड करने का विकल्प होगा (जब तक यह final या private )।

आपको java.util पैकेज में अच्छे उदाहरण मिलेगा जिसमें इंटरफेस शामिल हैं जैसे List और अमूर्त कक्षाएं जैसे AbstractList जो पहले से ही इंटरफ़ेस लागू करता है। आधिकारिक प्रलेखन AbstractList को निम्नानुसार वर्णित करता है:

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

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

इस अवधारणा को उदाहरण से बेहतर समझा जा सकता है:

एक भुगतान वर्ग पर विचार करें। भुगतान कई तरह से किया जा सकता है, जैसे कि पेपैल, क्रेडिट कार्ड आदि। इसलिए हम सामान्य रूप से हमारे इंटरफ़ेस के रूप में भुगतान करते हैं, जिसमें makePayment() विधि और क्रेडिट कार्ड और पेपैल दो कार्यान्वयन कक्षाएं हैं।

 public interface Payment { void makePayment();//by default it is a abstract method } public class PayPal implements Payment { public void makePayment() { //some logic for PayPal payment //eg Paypal uses username and password for payment } } public class CreditCard implements Payment { public void makePayment() { //some logic for CreditCard payment //eg CreditCard uses card number, date of expiry etc... } } 

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

हम एक अमूर्त वर्ग चुनते हैं जब कुछ विशेषताएं होती हैं जिसके लिए हम जानते हैं कि क्या करना है, और अन्य विशेषताएं जिन्हें हम जानते हैं कि कैसे करना है

निम्नलिखित उदाहरण पर विचार करें:

 public abstract class Burger { public void packing() { //some logic for packing a burger } public abstract void price(); //price is different for different categories of burgers } public class VegBerger extends Burger { public void price() { //set price for a veg burger. } } public class NonVegBerger extends Burger { public void price() { //set price for a non-veg burger. } } 

यदि हम भविष्य में एक निश्चित सार कक्षा में तरीकों (ठोस / सार) जोड़ते हैं, तो कार्यान्वयन वर्ग को इसके कोड में बदलाव की आवश्यकता नहीं होगी। हालांकि, अगर हम भविष्य में एक इंटरफ़ेस में तरीकों को जोड़ते हैं, तो हमें उस इंटरफ़ेस को कार्यान्वित करने वाले सभी कक्षाओं में कार्यान्वयन जोड़ना होगा, अन्यथा समय त्रुटियों को संकलित करना होगा।

अन्य मतभेद हैं लेकिन ये प्रमुख हैं जो आपके साक्षात्कारकर्ता की उम्मीद के अनुसार हो सकते हैं। उम्मीद है कि यह उपयोगी था

आपके सभी कथन आपके पहले कथन (जावा 8 जारी होने के बाद) के अलावा मान्य हैं:

जावा अंतरफलक के तरीके निहित रूप से सार हैं और कार्यान्वयन नहीं कर सकते हैं

दस्तावेज़ पृष्ठ से :

एक इंटरफ़ेस एक संदर्भ प्रकार है, एक वर्ग के समान, जिसमें केवल स्थिरांक, विधि हस्ताक्षर, डिफ़ॉल्ट विधियां, स्थिर विधियां, और नेस्टेड प्रकार शामिल हो सकते हैं

विधि निकायों केवल डिफ़ॉल्ट विधियों और स्थिर तरीकों के लिए मौजूद हैं।

डिफ़ॉल्ट विधियां:

एक इंटरफ़ेस डिफ़ॉल्ट तरीके हो सकते हैं, लेकिन सार कक्षाओं में सार तरीकों से अलग हैं

डिफ़ॉल्ट विधियां आपको अपनी लाइब्रेरीज़ के इंटरफेस में नई कार्यक्षमता जोड़ने और उन इंटरफेस के पुराने संस्करणों के लिए लिखे गए कोड के साथ द्विआधारी संगतता सुनिश्चित करने में सक्षम बनाती हैं।

जब आप कोई अंतरफलक बढ़ाते हैं जिसमें एक डिफ़ॉल्ट विधि होती है, तो आप निम्न कर सकते हैं:

  1. डिफ़ॉल्ट पद्धति का बिल्कुल भी उल्लेख न करें, जो आपके विस्तारित इंटरफ़ेस को डिफ़ॉल्ट विधि के रूप में प्राप्त करता है।
  2. डिफ़ॉल्ट विधि को दोबारा बनाएँ, जो इसे abstract बनाता है।
  3. डिफ़ॉल्ट विधि को फिर से परिभाषित करें, जो इसे ओवरराइड कर देता है।

स्थिर तरीके:

डिफ़ॉल्ट विधियों के अतिरिक्त, आप इंटरफेस में स्थिर तरीकों को परिभाषित कर सकते हैं। (एक स्थिर विधि एक ऐसा तरीका है जो कक्षा के साथ जुड़ा हुआ है, जिसमें किसी भी ऑब्जेक्ट के बजाय परिभाषित किया जाता है। क्लास के प्रत्येक उदाहरण इसकी स्थिर तरीके से शेयर करता है।)

यह आपके लिए आपके लाइब्रेरी में सहायक विधियों को व्यवस्थित करने के लिए आसान बनाता है;

static और default विधियों वाले interface बारे में दस्तावेज़ पृष्ठ से उदाहरण कोड।

 import java.time.*; public interface TimeClient { void setTime(int hour, int minute, int second); void setDate(int day, int month, int year); void setDateAndTime(int day, int month, int year, int hour, int minute, int second); LocalDateTime getLocalDateTime(); static ZoneId getZoneId (String zoneString) { try { return ZoneId.of(zoneString); } catch (DateTimeException e) { System.err.println("Invalid time zone: " + zoneString + "; using default time zone instead."); return ZoneId.systemDefault(); } } default ZonedDateTime getZonedDateTime(String zoneString) { return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString)); } } 

यह तय करने के लिए नीचे दिशानिर्देशों का उपयोग करें कि क्या इंटरफ़ेस या अमूर्त वर्ग का उपयोग करना है।

इंटरफेस:

  1. एक अनुबंध को परिभाषित करने के लिए (अधिमानतः स्टेटलेस – मेरा कोई मतलब नहीं है)
  2. असंबद्ध वर्गों से लिंक करने के लिए क्षमताओं हैं।
  3. सार्वजनिक स्थिर चर घोषित करने के लिए ( अपरिवर्तनीय राज्य )

सार वर्ग:

  1. कई निकटवर्ती संबंधित कक्षाओं में कोड साझा करें यह स्थापित एक संबंध है।

  2. संबंधित वर्गों के बीच सामान्य स्थिति साझा करें (राज्य को ठोस वर्गों में संशोधित किया जा सकता है)

संबंधित पोस्ट:

इंटरफ़ेस बनाम सार कक्षा (सामान्य ओ ओ)

इम्प्मेंट्स बनाम फैलता है: उपयोग करने के लिए कब? क्या फर्क पड़ता है?

इन उदाहरणों के माध्यम से जाकर, आप यह समझ सकते हैं कि

असंबद्ध वर्गों को इंटरफ़ेस के माध्यम से क्षमताएं हो सकती हैं लेकिन संबंधित कक्षाएं बेस कक्षाओं के विस्तार के माध्यम से व्यवहार को बदलती हैं।

Abstact वर्ग और इंटरफ़ेस के बीच अंतर

  1. जावा 8 में इंटरफेस बनाम सार वर्ग
  2. संकल्पनात्मक अंतर:

जावा 8 में अंतरफलक डिफ़ॉल्ट तरीके

  1. डिफ़ॉल्ट विधि क्या है?
  2. प्रत्येक विधि संकलन त्रुटि के लिए डिफ़ॉल्ट विधि का उपयोग कर हल किया
  3. डिफ़ॉल्ट विधि और एकाधिक वंशानुक्रम अस्पष्टता समस्याएं
  4. जावा इंटरफ़ेस डिफ़ॉल्ट विधियों के बारे में महत्वपूर्ण बिंदु:

जावा इंटरफेस स्टेटिक मेथड

  1. जावा इंटरफेस स्टेटिक मेथड, कोड उदाहरण, स्थिर विधि बनाम डिफ़ॉल्ट पद्धति
  2. जावा इंटरफेस स्थिर विधि के बारे में महत्वपूर्ण बिंदु:

जावा कार्यात्मक इंटरफेस



जावा 8 में इंटरफेस बनाम सार वर्ग

जावा 8 इंटरफ़ेस परिवर्तनों में स्थिर तरीके और इंटरफेस में डिफ़ॉल्ट विधियां शामिल हैं। जावा 8 से पहले, हम इंटरफेस में केवल विधि घोषणाएं कर सकते थे। लेकिन जावा 8 से, हम इंटरफ़ेस में डिफ़ॉल्ट विधियां और स्थिर तरीके हो सकते हैं।

डिफ़ॉल्ट पद्धति को पेश करने के बाद, ऐसा लगता है कि इंटरफेसेस और सार क्लासेस समान हैं। हालांकि, वे अभी भी जावा 8 में एक अलग अवधारणा हैं

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

संकल्पनात्मक अंतर:

सार वर्ग इंटरैसेस के कंकाल (यानी आंशिक) कार्यान्वयन के लिए मान्य हैं, लेकिन मेल इंटरफेस के बिना मौजूद नहीं होना चाहिए।

तो जब अमूर्त कक्षाएं प्रभावी ढंग से कम-दृश्यता के लिए कम हो जाती हैं, तो इंटरफेस के कंकाल लागू करने के तरीकों को भी इस तरह से दूर ले जा सकता है? निश्चय: नहीं! इंटरफेस कार्यान्वित करने के लिए लगभग कुछ या सभी क्लास-बिल्डिंग टूल की आवश्यकता होती है, जो डिफ़ॉल्ट तरीकों की कमी होती है। और अगर कोई इंटरफ़ेस नहीं करता है, तो यह स्पष्ट रूप से एक विशेष मामला है, जिसे आपको भटका नहीं लेना चाहिए।

जावा 8 में अंतरफलक डिफ़ॉल्ट तरीके

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

यह कैसे काम करता है यह समझने के लिए छोटे उदाहरण पर विचार करें:

 public interface OldInterface {    public void existingMethod();    default public void newDefaultMethod() {        System.out.println("New default method"               + " is added in interface");    } } 

निम्नलिखित क्लास जावा JDK 8 में सफलतापूर्वक संकलित करेगा,

 public class OldInterfaceImpl implements OldInterface {    public void existingMethod() {     // existing implementation is here…    } } 

यदि आप OldInterfaceImpl का एक उदाहरण बनाते हैं:

 OldInterfaceImpl obj = new OldInterfaceImpl (); // print “New default method add in interface” obj.newDefaultMethod(); 

डिफ़ॉल्ट विधि:

डिफ़ॉल्ट विधियां कभी भी अंतिम नहीं होतीं, सिंक्रनाइज़ नहीं की जा सकतीं और ऑब्जेक्ट के तरीकों को ओवरराइड नहीं कर सकता। वे हमेशा सार्वजनिक होते हैं, जो छोटे और पुन: प्रयोज्य विधियों को लिखने की क्षमता को गंभीर रूप से सीमित करता है।

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

इन इंटरफेस के पुराने कार्यान्वयन को तोड़ने के बिना डिफ़ॉल्ट तरीकों मौजूदा इंटरफेस में नई कार्यक्षमता जोड़ने में सक्षम हैं।

जब हम कोई अंतरफलक बढ़ाते हैं जिसमें एक डिफ़ॉल्ट विधि होती है, तो हम निम्नलिखित का पालन कर सकते हैं,

  1. डिफ़ॉल्ट पद्धति को ओवरराइड न करें और डिफ़ॉल्ट विधि को प्राप्त होगा।
  2. अन्य तरीकों के समान डिफ़ॉल्ट पद्धति को ओवरराइड करें जो हम उपवर्ग में ओवरराइड करते हैं।
  3. सार के रूप में डिफ़ॉल्ट विधि redeclare, जो subclass इसे ओवरराइड करने के लिए मजबूर करते हैं।

प्रत्येक विधि संकलन त्रुटि के लिए डिफ़ॉल्ट विधि का उपयोग कर हल किया

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

 public interface Iterable<T> {    public void forEach(Consumer<? super T> consumer); } 

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

डिफ़ॉल्ट विधि के साथ इटेरेबल इंटरफ़ेस नीचे है,

 public interface Iterable<T> {    public default void forEach(Consumer                   <? super T> consumer) {        for (T t : this) {            consumer.accept(t);        }    } } 

कार्यान्वयन वर्ग को तोड़ने के बिना जेडीके इंटरफेस में स्ट्रीम जोड़ने के लिए एक ही तंत्र का इस्तेमाल किया गया है।


डिफ़ॉल्ट विधि और एकाधिक वंशानुक्रम अस्पष्टता समस्याएं

चूंकि जावा क्लास कई इंटरफेस लागू कर सकता है और प्रत्येक इंटरफेस उसी विधि हस्ताक्षर के साथ डिफ़ॉल्ट विधि को परिभाषित कर सकते हैं, इसलिए, इनहेरिट की गई विधियां एक-दूसरे के साथ संघर्ष कर सकती हैं।

उदाहरण के नीचे विचार करें,

 public interface InterfaceA {       default void defaultMethod(){           System.out.println("Interface A default method");    } } public interface InterfaceB {   default void defaultMethod(){       System.out.println("Interface B default method");   } } public class Impl implements InterfaceA, InterfaceB { } 

उपरोक्त कोड निम्न त्रुटि के साथ संकलन करने में असफल रहेगा,

java: class इंपल को किसी भी तरह से डिफ़ॉल्ट रूप से गलत तरीके से संसाधित नहीं किया जाता है, प्रकार इंटरफ़ेस और इंटरफ़ेस बी से

इस श्रेणी को ठीक करने के लिए, हमें डिफ़ॉल्ट पद्धति कार्यान्वयन प्रदान करने की आवश्यकता है:

 public class Impl implements InterfaceA, InterfaceB {    public void defaultMethod(){    } } 

इसके अलावा, अगर हम अपने स्वयं के क्रियान्वयन के बजाय किसी भी सुपर इंटरफेस द्वारा प्रदान किए गए डिफ़ॉल्ट कार्यान्वयन को लागू करना चाहते हैं, तो हम निम्नानुसार ऐसा कर सकते हैं,

 public class Impl implements InterfaceA, InterfaceB {    public void defaultMethod(){        // existing code here..        InterfaceA.super.defaultMethod();    } } 

हम अपनी नई विधि के हिस्से के रूप में किसी भी डिफ़ॉल्ट कार्यान्वयन या दोनों का चयन कर सकते हैं।

जावा इंटरफ़ेस डिफ़ॉल्ट विधियों के बारे में महत्वपूर्ण बिंदु:

  1. कार्यान्वयन कक्षाओं को तोड़ने के डर के बिना जावा अंतरफलक डिफ़ॉल्ट विधियों हमें इंटरफेस को विस्तार देने में मदद करेगा।
  2. जावा अंतरफलक डिफ़ॉल्ट विधियों ने इंटरफेस और अमूर्त कक्षाओं के बीच अंतर को पुल कर दिया है।
  3. जावा 8 इंटरफ़ेस डिफ़ॉल्ट विधियां उपयोगिता कक्षाओं से बचने में हमारी मदद करेगी, जैसे कि सभी संग्रह वर्ग पद्धतियां इंटरफेस में स्वयं उपलब्ध कराई जा सकती हैं।
  4. जावा इंटरफ़ेस डिफ़ॉल्ट विधियों हमें आधार कार्यान्वयन वर्गों को निकालने में मदद मिलेगी, हम डिफ़ॉल्ट कार्यान्वयन प्रदान कर सकते हैं और कार्यान्वयन वर्ग यह चुन सकते हैं कि कौन सा ओवरराइड करेगा।
  5. लैम्ब्डा भावों को समर्थन देने के लिए जावा 8 में कलेक्शंस एपीआई को बढ़ाने के लिए इंटरफेस में डिफ़ॉल्ट तरीकों को पेश करने का प्रमुख कारण है।
  6. यदि पदानुक्रम में किसी भी वर्ग में एक ही हस्ताक्षर के साथ एक विधि है, तो डिफ़ॉल्ट विधियां अप्रासंगिक हो जाती हैं। एक डिफ़ॉल्ट विधि java.lang.Object से किसी विधि को ओवरराइड नहीं कर सकती। तर्क बहुत सरल है, क्योंकि ऑब्जेक्ट सभी जावा कक्षाओं के लिए आधार वर्ग है। तो भी अगर हमारे पास इंटरफ़ेस में डिफ़ॉल्ट पद्धतियों के रूप में परिभाषित ऑब्जेक्ट क्लास विधियों हैं, तो यह बेकार होगा क्योंकि ऑब्जेक्ट क्लास विधि का हमेशा इस्तेमाल किया जाएगा यही कारण है कि भ्रम से बचने के लिए, हम डिफ़ॉल्ट पद्धतियां नहीं कर सकते हैं जो ऑब्जेक्ट क्लास विधियों को ओवरराइड कर रहे हैं।
  7. जावा इंटरफ़ेस डिफ़ॉल्ट विधियों को डिफेंडर विधियों या वर्चुअल एक्सटेंशन विधियों के रूप में भी जाना जाता है।

संसाधन लिंक:

  1. जावा 8 में डिफ़ॉल्ट वर्ग बनाम सार वर्ग के साथ अंतरफलक
  2. जेडीके 8 युग में सार वर्ग बनाम इंटरफ़ेस
  3. आभासी विस्तार विधियों के माध्यम से इंटरफ़ेस विकास

जावा इंटरफेस स्टेटिक मेथड

जावा इंटरफेस स्टेटिक मेथड, कोड उदाहरण, स्थिर विधि बनाम डिफ़ॉल्ट पद्धति

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

 public interface MyData { default void print(String str) { if (!isNull(str)) System.out.println("MyData Print::" + str); } static boolean isNull(String str) { System.out.println("Interface Null Check"); return str == null ? true : "".equals(str) ? true : false; } } 

अब आइए एक कार्यान्वयन वर्ग देखें जो कि नल () विधि खराब कार्यान्वयन के साथ है।

 public class MyDataImpl implements MyData { public boolean isNull(String str) { System.out.println("Impl Null Check"); return str == null ? true : false; } public static void main(String args[]){ MyDataImpl obj = new MyDataImpl(); obj.print(""); obj.isNull("abc"); } } 

ध्यान रखें कि isNull (स्ट्रिंग str) एक साधारण वर्ग विधि है, यह इंटरफ़ेस विधि को ओवरराइड नहीं कर रहा है। उदाहरण के लिए, यदि हम "न्यल () विधि में ओवरराइड एनोटेशन जोड़ देंगे, तो इसके परिणामस्वरूप कंपाइलर त्रुटि होगी।

अब जब हम आवेदन चलाएंगे, तो हम आउटपुट प्राप्त करेंगे।

इंटरफ़ेस नल चेक

इप्लॉग नल चेक

अगर हम इंटरफ़ेस विधि को स्थिर से डिफ़ॉल्ट पर बनाते हैं, तो हम निम्न आउटपुट प्राप्त करेंगे।

इप्लॉग नल चेक

माइडा प्रिंट ::

इप्लॉग नल चेक

जावा इंटरफ़ेस स्थिर विधि केवल इंटरफ़ेस विधियों के लिए दृश्यमान है, यदि हम MyDataImpl वर्ग से isNull () विधि को निकालते हैं, तो हम इसे MyDataImpl ऑब्जेक्ट के लिए उपयोग करने में सक्षम नहीं होंगे। हालांकि अन्य स्थिर तरीकों की तरह, हम कक्षा नाम का उपयोग करके इंटरफ़ेस स्थिर तरीकों का उपयोग कर सकते हैं। उदाहरण के लिए, एक वैध वक्तव्य होगा:

 boolean result = MyData.isNull("abc"); 

जावा इंटरफेस स्थिर विधि के बारे में महत्वपूर्ण बिंदु:

  1. जावा इंटरफ़ेस स्थिर विधि इंटरफ़ेस का हिस्सा है, हम इसका कार्यान्वयन वर्ग ऑब्जेक्ट के लिए उपयोग नहीं कर सकते।
  2. जावा इंटरफ़ेस स्थिर तरीके उपयोगिता के तरीके प्रदान करने के लिए अच्छे हैं, उदाहरण के लिए रिक्त चेक, संग्रहण सॉर्टिंग इत्यादि।
  3. जावा इंटरफेस स्थिर विधि कार्यान्वयन कक्षाओं को ओवरराइड करने की इजाजत नहीं देकर सुरक्षा प्रदान करने में हमारी मदद करता है।
  4. हम ऑब्जेक्ट क्लास विधियों के लिए इंटरफ़ेस स्टैटिक विधि को परिभाषित नहीं कर सकते हैं, हम कंपाइलर एरर के रूप में "यह स्टैटिक मेथ ऑब्जेक्ट से इंस्टेंस इमेज छिपा नहीं सकते" ऐसा इसलिए है क्योंकि जावा में इसकी अनुमति नहीं है, चूंकि ऑब्जेक्ट सभी वर्गों के लिए आधार वर्ग है और हमारे पास एक ही वर्ग स्तर की स्थिर विधि नहीं हो सकती है और एक ही सिग्नेचर के साथ एक और तरीका विधि हो सकती है।
  5. उपयोगिता कक्षाएं जैसे कलेक्शंस को निकालने के लिए हम जावा इंटरफेस स्टैटिक तरीके का उपयोग कर सकते हैं और इसके सभी स्थिर तरीकों को संबंधित इंटरफेस में ले जा सकते हैं, जो कि खोजने और उपयोग करना आसान होगा।

जावा कार्यात्मक इंटरफेस

पद समाप्त करने से पहले, मैं कार्यात्मक इंटरफेस के लिए एक संक्षिप्त परिचय प्रदान करना चाहता हूं। बिल्कुल एक सार पद्धति के साथ एक इंटरफ़ेस को कार्यात्मक इंटरफ़ेस के रूप में जाना जाता है।

कार्यात्मक इंटरफ़ेस के रूप में इंटरफेस को चिह्नित करने के लिए एक नई एनोटेशन @FunctionalInterface इंटरफेस को पेश किया गया है। @FunctionalInterface एनोटेशन कार्यात्मक इंटरफेस में सार विधियों के आकस्मिक अतिरिक्त से बचने की सुविधा है। इसका प्रयोग करने के लिए वैकल्पिक लेकिन अच्छा अभ्यास है

कार्यात्मक इंटरफेस लंबे समय से प्रतीक्षा कर रहे हैं और जावा 8 की सुविधा के लिए बहुत ज्यादा मांग की गई है क्योंकि यह हमें लैम्ब्डा भावों का इस्तेमाल करने के लिए सक्षम बनाता है। लैम्ब्डा भाव और विधि संदर्भों के लिए लक्ष्य प्रकार प्रदान करने के लिए कार्यात्मक इंटरफेस के गुच्छा के साथ एक नया पैकेज java.util.function जोड़ा जाता है। भविष्य के पदों में हम कार्यात्मक इंटरफेस और लैम्ब्डा भाव देख सकते हैं।

संसाधन स्थान:

  1. जावा 8 इंटरफ़ेस परिवर्तन – स्थिर विधि, डिफ़ॉल्ट विधि

आपका स्पष्टीकरण अच्छा दिखता है, लेकिन ऐसा लग सकता है कि आप इसे एक पाठ्यपुस्तक से पढ़ रहे थे? : – /

मैं किस बारे में अधिक परेशान हूं, यह आपके उदाहरण के लिए कितना ठोस था? क्या आप सार और इंटरफेस के बीच लगभग सभी अंतर शामिल करने के लिए परेशान थे?

निजी तौर पर, मैं इस लिंक का सुझाव दूंगा : http://mindprod.com/jgloss/interfacevsabstract.html#TABLE

मतभेदों की संपूर्ण सूची के लिए ..

आशा है कि यह आपके और अन्य सभी पाठकों को उनके भविष्य के साक्षात्कार में मदद करता है

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

इंटरफेस और अमूर्त वर्ग, हालांकि तकनीकी दृष्टि से जाहिरा तौर पर समान हैं, पूरी तरह से अलग अर्थ और प्रयोजन हैं।

सारांश

  1. एक इंटरफेस एक अनुबंध को परिभाषित करता है कि कुछ कार्यान्वयन आपके लिए पूरा करेगा।

  2. एक सार वर्ग एक डिफ़ॉल्ट व्यवहार प्रदान करता है कि आपका कार्यान्वयन पुन: उपयोग कर सकता है।

ऊपर दिए गए ये दो बिंदु हैं, जब साक्षात्कार के लिए मैं देख रहा हूं, और एक कॉम्पैक्ट पर्याप्त सारांश है। अधिक जानकारी के लिए पढ़ें।

वैकल्पिक सारांश

  1. एक इंटरफ़ेस सार्वजनिक API को परिभाषित करने के लिए है
  2. एक अमूर्त वर्ग आंतरिक उपयोग के लिए है, और SPI को परिभाषित करने के लिए

उदाहरण द्वारा

इसे अलग तरीके से दर्ज करने के लिए: एक कंक्रीट वर्ग वास्तविक काम करता है, बहुत विशिष्ट तरीके से। उदाहरण के लिए, एक ArrayList ऑब्जेक्ट्स की एक सूची को एक कॉम्पैक्ट तरीके से स्टोर करने के लिए स्मृति के निकटतम क्षेत्र का उपयोग करता है जिसमें तेजी से यादृच्छिक पहुंच, पुनरावृत्ति, और इन-प्लेस परिवर्तन शामिल हैं, लेकिन सम्मिलन, विलोपन और कभी-कभी भी अतिरिक्त पर भयानक है; इस बीच, एक LinkedList ऑब्जेक्ट्स की सूची को संग्रहित करने के लिए डबल-लिंक किए गए नोड्स का उपयोग करता है, जो इसके बजाय तेजी से चलना, इन-प्लेस परिवर्तन और प्रविष्टि / हटाए जाने / जोड़ता प्रदान करता है, लेकिन रैंडम एक्सेस पर भयानक है। इन दो प्रकार की सूचियों को विभिन्न उपयोग के मामलों के लिए अनुकूलित किया गया है, और यह बहुत मायने रखता है कि आप उनका उपयोग कैसे करेंगे। जब आप उस सूची के प्रदर्शन को निचोड़ने की कोशिश कर रहे हैं, जिसमें आप बहुत अधिक से बातचीत कर रहे हैं, और जब प्रकार की सूची चुनते समय आपके ऊपर निर्भर होता है, तो आपको सावधानी से चुनना चाहिए कि आप कौन से तत्काल प्रवेश कर रहे हैं

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

एक अमूर्त वर्ग इंटरफेस और कंक्रीट वर्गों के मध्य में है। यह कार्यान्वयन को आम या उबाऊ कोड साझा करने में मदद करने के लिए माना जाता है। उदाहरण के लिए, addAll , addAll आकार के आधार पर आधारभूत कार्यान्वयन प्रदान करता है, contains पुनरावृत्त और तुलना की जाती है, दोहराया जाने वाला add , और इतने पर। इससे कार्यान्वयन उन महत्वपूर्ण हिस्सों पर केंद्रित होता है जो उन दोनों के बीच अंतर करते हैं: वास्तव में डेटा को कैसे संग्रहीत और पुनः प्राप्त किया जाए

एक अन्य परिप्रेक्ष्य: एपीआई बनाम एसपीआई

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

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

एक एपीआई और एक एसपीआई के बीच का अंतर सूक्ष्म है, लेकिन महत्वपूर्ण है: एपीआई के लिए, फोकस इसका इस्तेमाल करता है, और एसपीआई के लिए यह ध्यान लगाता है कि कौन इसे लागू करता है।

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

जावा 8 और डिफ़ॉल्ट तरीकों पर एक नोट

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

"पुस्तक ज्ञान"

ओपी के जवाब में दिए गए तकनीकी विवरण को "पुस्तक ज्ञान" माना जाता है क्योंकि यह आमतौर पर स्कूल में इस्तेमाल होने वाला दृष्टिकोण और एक भाषा के बारे में सबसे अधिक तकनीकी पुस्तकों में होता है: यह एक बात है, यह कैसे अभ्यास में उपयोग करने के लिए नहीं है, विशेष रूप से बड़े पैमाने पर अनुप्रयोगों में ।

यहाँ एक समानता है: माना जाता है कि सवाल यह था:

प्रोम रात, एक कार या होटल के कमरे के लिए किराए पर बेहतर क्या है?

तकनीकी उत्तर लगता है:

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

यह सब सच है, लेकिन पूरी तरह से अंक याद करते हैं कि वे दो पूरी तरह से अलग चीजें हैं, और दोनों ही एक ही समय में विभिन्न उद्देश्यों के लिए इस्तेमाल किया जा सकता है, और "यह कर" पहलू दो विकल्पों में से किसी के बारे में सबसे महत्वपूर्ण बात नहीं है । जवाब में परिप्रेक्ष्य का अभाव है, यह एक अपरिपक्व तरीके से सोचता है, जबकि सही "तथ्यों" को सही ढंग से पेश किया जा रहा है

एक इंटरफ़ेस एक "अनुबंध" है जहां अनुबंध लागू करने वाले वर्ग के तरीकों को लागू करने का वादा किया जाता है। एक उदाहरण जहां मुझे एक वर्ग के बजाय इंटरफ़ेस लिखना था, जब मैं 2 डी से 3 डी तक एक गेम को नवीनीकरण कर रहा था मुझे गेम के 2 डी और 3 डी संस्करण के बीच वर्गों को साझा करने के लिए इंटरफ़ेस बनाना था।

 package adventure; import java.awt.*; public interface Playable { public void playSound(String s); public Image loadPicture(String s); } 

तब मैं पर्यावरण के आधार पर तरीकों को लागू कर सकता हूं, जबकि वह उन तरीकों को ऐसे किसी वस्तु से कॉल करने में सक्षम है, जो यह नहीं जानता कि गेम का कौन सा संस्करण लोड हो रहा है।

public class Adventure extends JFrame implements Playable

public class Dungeon3D extends SimpleApplication implements Playable

public class Main extends SimpleApplication implements AnimEventListener, ActionListener, Playable

आमतौर पर, गेमवर्ल्ड में, दुनिया एक अमूर्त वर्ग हो सकती है जो इस खेल पर तरीकों का प्रदर्शन करती है:

 public abstract class World... public Playable owner; public Playable getOwner() { return owner; } public void setOwner(Playable owner) { this.owner = owner; } 

निम्नलिखित तरीके पर विचार करने के बारे में क्या है:

  • A relationship between a class and an abstract class is of type "is-a"
  • A relationship between a class and an interface is of type "has-a"

So when you have an abstract class Mammals, a subclass Human, and an interface Driving, then you can say

  • each Human is-a Mammal
  • each Human has-a Driving (behavior)

My suggestion is that the book knowledge phrase indicates that he wanted to hear the semantic difference between both (like others here already suggested).

Abstract classes are meant to be inherited from, and when one class inherits from another it means that there is a strong relationship between the 2 classes. With an interface on the other hand, the relationship between the interface itself and the class implementing the interface is not necessarily strong. So, we can summarize this first point by saying that an abstract class would be more appropriate when there is a strong relationship between the abstract class and the classes that will derive from it. Again, this is because an abstract class is very closely linked to inheritance, which implies a strong relationship. But, with interfaces there need not be a strong relationship between the interface and the classes that implement the interface. Java interface can extend multiple interface also Java class can implement multiple interfaces, Which means interface can provide more polymorphism support than abstract class . By extending abstract class, a class can only participate in one Type hierarchy but by using interface it can be part of multiple type hierarchies.

In order to implement interface in Java, until your class is abstract, you need to provide implementation of all methods, which is very painful. On the other hand abstract class may help you in this case by providing default implementation.

Abstract classes are not pure abstraction bcz its collection of concrete(implemented methods) as well as unimplemented methods. But Interfaces are pure abstraction bcz there are only unimplemented methods not concrete methods.

Why Abstract classes?

  1. If user want write common functionality for all objects.
  2. Abstract classes are best choice for reimplementation in future that to add more functionality without affecting of end user.

Why Interfaces?

  1. If user want to write different functionality that would be different functionality on objects.
  2. Interfaces are best choice that if not need to modify the requirements once interface has been published.

The main difference what i have observed was that abstract class provides us with some common behaviour implemented already and subclasses only needs to implement specific functionality corresponding to them. where as for an interface will only specify what tasks needs to be done and no implementations will be given by interface. I can say it specifies the contract between itself and implemented classes.

An interface is like a set of genes that are publicly documented to have some kind of effect: A DNA test will tell me whether I've got them – and if I do, I can publicly make it known that I'm a "carrier" and part of my behavior or state will conform to them. (But of course, I may have many other genes that provide traits outside this scope.)

An abstract class is like the dead ancestor of a single-sex species (*): She can't be brought to life but a living (ie non-abstract ) descendant inherits all her genes.

(*) To stretch this metaphor, let's say all members of the species live to the same age. This means all ancestors of a dead ancestor must also be dead – and likewise, all descendants of a living ancestor must be alive.

I do interviews for work and i would look unfavourably on your answer aswell (sorry but im very honest). It does sound like you've read about the difference and revised an answer but perhaps you have never used it in practice.

A good explanation as to why you would use each can be far better than having a precise explanation of the difference. Employers ultimatley want programers to do things not know them which can be hard to demonstrate in an interview. The answer you gave would be good if applying for a technical or documentation based job but not a developers role.

Best of luck with interviews in the future.

Also my answer to this question is more about interview technique rather than the technical material youve provided. Perhaps consider reading about it. https://workplace.stackexchange.com/ can be an excellent place for this sort of thing.

An interface is purely abstract. we dont have any implementation code in interface.

Abstract class contains both methods and its implementation.

click here to watch tutorial on interfaces and abstract classes

The main difference what i have observed was that abstract class provides us with some common behaviour implemented already and subclasses only needs to implement specific functionality corresponding to them. where as for an interface will only specify what tasks needs to be done and no implementations will be given by interface. I can say it specifies the contract between itself and implemented classes.

You choose Interface in Java to avoid the Diamond Problem in multiple inheritance .

If you want all of your methods to be implemented by your client you go for interface. It means you design the entire application at abstract.

You choose abstract class if you already know what is in common. For example Take an abstract class Car . At higher level you implement the common car methods like calculateRPM() . It is a common method and you let the client implement his own behavior like
calculateMaxSpeed() etc. Probably you would have explained by giving few real time examples which you have encountered in your day to day job.

Even I have faced the same question in multiple interviews and believe me it makes your time miserable to convince the interviewer. If I inherent all the answers from above then I need to add one more key point to make it more convincing and utilizing OO at its best

In case you are not planning any modification in the rules , for the subclass to be followed, for a long future, go for the interface, as you wont be able to modify in it and if you do so, you need to go for the changes in all the other sub classes, whereas, if you think, you want to reuse the functionality, set some rules and also make it open for modification , go for Abstract class.

Think in this way, you had used a consumable service or you had provided some code to world and You have a chance to modify something, suppose a security check And If I am being a consumer of the code and One morning after a update , I find all read marks in my Eclipse, entire application is down. So to prevent such nightmares, use Abstract over Interfaces

I think this might convince the Interviewer to a extent…Happy Interviews Ahead.

From what I understand, an Interface, which is comprised of final variables and methods with no implementations, is implemented by a class to obtain a group of methods or methods that are related to each other. On the other hand, an abstract class, which can contain non-final variables and methods with implementations, is usually used as a guide or as a superclass from which all related or similar classes inherits from. In other words, an abstract class contains all the methods/variables that are shared by all its subclasses.

In abstract class, you can write default implementation of methods! But in Interface you can not. Basically, In interface there exist pure virtual methods which have to be implemented by the class which implements the interface.

hmm now the people are hungery practical approach, you are quite right but most of interviewer looks as per their current requirment and want a practical approach.

after finishing your answer you should jump on the example:

सार:

for example we have salary function which have some parametar common to all employee. then we can have a abstract class called CTC with partialy defined method body and it will got extends by all type of employee and get redeined as per their extra beefits. For common functonality.

 public abstract class CTC { public int salary(int hra, int da, int extra) { int total; total = hra+da+extra; //incentive for specific performing employee //total = hra+da+extra+incentive; return total; } } class Manger extends CTC { } class CEO extends CTC { } class Developer extends CTC { } 

इंटरफेस

interface in java allow to have interfcae functionality without extending that one and you have to be clear with the implementation of signature of functionality that you want to introduce in your application. it will force you to have definiton. For different functionality. public interface EmployeType {

  public String typeOfEmployee(); } class ContarctOne implements EmployeType { @Override public String typeOfEmployee() { return "contract"; } } class PermanentOne implements EmployeType { @Override public String typeOfEmployee() { return "permanent"; } } 

you can have such forced activity with abstract class too by defined methgos as a abstract one, now a class tha extends abstract class remin abstract one untill it override that abstract function.

When I am trying to share behavior between 2 closely related classes, I create an abstract class that holds the common behavior and serves as a parent to both classes.

When I am trying to define a Type, a list of methods that a user of my object can reliably call upon, then I create an interface.

For example, I would never create an abstract class with 1 concrete subclass because abstract classes are about sharing behavior. But I might very well create an interface with only one implementation. The user of my code won't know that there is only one implementation. Indeed, in a future release there may be several implementations, all of which are subclasses of some new abstract class that didn't even exist when I created the interface.

That might have seemed a bit too bookish too (though I have never seen it put that way anywhere that I recall). If the interviewer (or the OP) really wanted more of my personal experience on that, I would have been ready with anecdotes of an interface has evolved out of necessity and visa versa.

One more thing. Java 8 now allows you to put default code into an interface, further blurring the line between interfaces and abstract classes. But from what I have seen, that feature is overused even by the makers of the Java core libraries. That feature was added, and rightly so, to make it possible to extend an interface without creating binary incompatibility. But if you are making a brand new Type by defining an interface, then the interface should be JUST an interface. If you want to also provide common code, then by all means make a helper class (abstract or concrete). Don't be cluttering your interface from the start with functionality that you may want to change.

I will try to answer using practical scenario to show the distinction between the two.

Interfaces come with zero payload ie no state has to be maintained and thus are better choice to just associate a contract (capability) with a class.

For example, say I have a Task class that performs some action, now to execute a task in separate thread I don't really need to extend Thread class rather better choice is to make Task implement Runnable interface (ie implement its run() method) and then pass object of this Task class to a Thread instance and call its start() method.

Now you can ask what if Runnable was a abstract class?

Well technically that was possible but design wise that would have been a poor choice reason being:

  • Runnable has no state associated with it and neither it 'offers' any default implementation for the run() method
  • Task would have to extend it thus it couldn't extend any other class
  • Task has nothing to offer as specialization to Runnable class, all it needs is to override run() method

In other words, Task class needed a capability to be run in a thread which it achieved by implementing Runnable interface verses extending the Thread class that would make it a thread.

Simply put us interface to define a capability (contract), while use a abstract class to define skeleton (common/partial) implementation of it.

Disclaimer: silly example follows, try not to judge 😛

 interface Forgiver { void forgive(); } abstract class GodLike implements Forgiver { abstract void forget(); final void forgive() { forget(); } } 

Now you have been given a choice to be GodLike but you may choose to be Forgiver only (ie not GodLike) and do:

 class HumanLike implements Forgiver { void forgive() { // forgive but remember } } 

Or you may may choose to be GodLike and do:

 class AngelLike extends GodLike { void forget() { // forget to forgive } } 

PS with java 8 interface can also have static as well default (overridable implementation) methods and thus difference b/w interface and abstract class is even more narrowed down.

Almost everything seems to be covered here already.. Adding just one more point on practical implementation of abstract class:

abstract keyword is also used just prevent a class from being instantiated. If you have a concrete class which you do not want to be instantiated – Make it abstract .

From what I understand and how I approach,

Interface is like a specification/contract, any class that implements a interface class have to implement all the methods defined in the abstract class (except default methods (introduced in java 8))

Whereas I define a class abstract when I know the implementation required for some methods of the class and some methods I still do not know what will be the implementation(we might know the function signature but not the implementation). I do this so that later in the part of development when i know how these methods are to be implemented, i can just extend this abstract class and implement these methods.

Note: You cannot have function body in interface methods unless the method is static or default.

I believe what the interviewer was trying to get at was probably the difference between interface and implementation.

The interface – not a Java interface, but "interface" in more general terms – to a code module is, basically, the contract made with client code that uses the interface.

The implementation of a code module is the internal code that makes the module work. Often you can implement a particular interface in more than one different way, and even change the implementation without client code even being aware of the change.

A Java interface should only be used as an interface in the above generic sense, to define how the class behaves for the benefit of client code using the class, without specifying any implementation. Thus, an interface includes method signatures – the names, return types, and argument lists – for methods expected to be called by client code, and in principle should have plenty of Javadoc for each method describing what that method does. The most compelling reason for using an interface is if you plan to have multiple different implementations of the interface, perhaps selecting an implementation depending on deployment configuration.

A Java abstract class, in contrast, provides a partial implementation of the class, rather than having a primary purpose of specifying an interface. It should be used when multiple classes share code, but when the subclasses are also expected to provide part of the implementation. This permits the shared code to appear in only one place – the abstract class – while making it clear that parts of the implementation are not present in the abstract class and are expected to be provided by subclasses.

your answer is right but the interviewer needs you to differentiate according to software engineering perspective not according to the details of Java.

Simple words:

An Interface is like the interface of a shop anything that is shown on it should be there in the shop, so any method in the Interface must be there implemented in the concrete class. Now what if some classes share some exact methods and varies in others. Suppose the Interface is about a shop that contains two things and suppose we have two shops both contain sport equipment but one has clothes extra and the other has shoes extra. So what you do is making an abstract class for Sport that implements the Sports method and leave the other method unimplemented. Abstract class here means that this shop doesn't exist itself but it is the base for other classes/shops. This way you are organising the code, avoiding errors of replicating the code, unifying the code, and ensuring re-usability by some other class.

Your answer is ok, but I think he was looking for this kind of answer:

Abstract class

  • सार कक्षा में सार और गैर-सार विधियां हो सकती हैं।
  • सार वर्ग एकाधिक विरासत का समर्थन नहीं करता है।
  • सार वर्ग अंतिम, गैर-अंतिम, स्थिर और गैर-स्थिर चर हो सकते हैं।
  • सार वर्ग अंतरफलक के कार्यान्वयन प्रदान कर सकता है।

इंटरफेस

  • Interface can have default, static and abstract methods.
  • इंटरफ़ेस एकाधिक विरासत का समर्थन करता है।
  • इंटरफ़ेस में केवल स्थिर और अंतिम चर है
  • Interface can't provide the implementation of abstract class.

Yes, your responses were technically correct but where you went wrong was not showing them you understand the upsides and downsides of choosing one over the other. Additionally, they were probably concerned/freaked out about compatibility of their codebase with upgrades in the future. This type of response may have helped (in addition to what you said):

"Choosing an Abstract Class over an Interface Class depends on what we project the future of the code will be.

Abstract classes allow better forward-compatibility because you can continue adding behavior to an Abstract Class well into the future without breaking your existing code –> this is not possible with an Interface Class.

On the other hand, Interface Classes are more flexible than Abstract Classes. This is because they can implement multiple interfaces . The thing is Java does not have multiple inheritances so using abstract classes won't let you use any other class hierarchy structure…

So, in the end a good general rule of thumb is: Prefer using Interface Classes when there are no existing/default implementations in your codebase. And, use Abstract Classes to preserve compatibility if you know you will be updating your class in the future."

Good luck on your next interview!