दिलचस्प पोस्ट
जावामेल एक्सचेंज प्रमाणीकरण एक स्ट्रिंग से एक क्लास को इंस्टाइएट करें परियोजना की त्रुटि: क्यूटी में अज्ञात मॉड्यूल (एस): वेबकिटविड्ट्स हेरोको की निष्क्रियता को रोकने का आसान तरीका? सिंगलटन के कार्यान्वयन पर स्थैतिक वर्ग क्यों चुनें? JsonConvert का उपयोग करना। DerserializeObject एक सी # POCO वर्ग के लिए जेसन को डीएसराइलाइज़ करना एक uber जार क्या है? क्या कार्रवाई फील्टर गुण थ्रेड्स में पुन: उपयोग किए जा रहे हैं? वह कैसे काम करता है? लिनक्स वीआई तीर कुंजी को सम्मिलित मोड में तोड़ दिया WPF में गिटार chords संपादक बनाएँ (RichTextBox से?) INPUT तत्व के लिए "परिवर्तन" और "इनपुट" ईवेंट में अंतर क्या है एंड्रॉइड प्रोजेक्ट में लाइब्रेरी प्रोजेक्ट कैसे जोड़ूं? क्यूडा और क्लासेस सीएसएस: इनलाइन एसवीजी से पहले कोणीय सामग्री में एमडी-डेडेक्कर का प्रारूप बदलें

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

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

मेरे अनुभव से मुझे लगता है कि निम्नलिखित सच है। अगर मुझे एक प्रमुख बात याद आ रही है तो कृपया मुझे बताएं

इंटरफेस:

एक इंटरफेस में घोषित प्रत्येक एकल विधि को उपवर्ग में कार्यान्वित करना होगा। इंटरफेस में केवल ईवेंट, प्रतिनिधि, गुण (सी #) और तरीके मौजूद हो सकते हैं। एक क्लास एकाधिक इंटरफेस लागू कर सकता है

सार कक्षा:

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

  1. आखिरकार, साक्षात्कारकर्ता प्रश्न के साथ आया, "क्या होगा यदि आपके पास सार तत्वों के साथ एक सार वर्ग था? यह अंतरफलक से कैसे अलग होगा?" मुझे जवाब नहीं पता था, लेकिन मुझे लगता है कि यह उपर्युक्त ऊपर वर्णित विरासत है?

  2. एक और साक्षात्कारकर्ता ने मुझसे पूछा कि क्या आपके पास इंटरफ़ेस के अंदर एक सार्वजनिक वैरिएबल है, तो यह कैसे एब्सचर क्लास से अलग होगा? मैंने जोर दिया कि आप एक इंटरफेस के अंदर एक सार्वजनिक वैरिएबल नहीं कर सकते। मुझे नहीं पता था कि वह क्या सुनना चाहता था लेकिन वह भी संतुष्ट नहीं थे

यह भी देखें :

  • एक अमूर्त वर्ग के बजाय एक अंतरफलक का उपयोग करने के लिए और इसके विपरीत

  • इंटरफेस बनाम सार क्लासेस

  • आप एक सार कक्षा और एक इंटरफ़ेस के उपयोग के बीच कैसे तय करते हैं?

  • इंटरफ़ेस और अमूर्त वर्ग के बीच अंतर क्या है?

Solutions Collecting From Web of "इंटरफ़ेस बनाम सार कक्षा (सामान्य ओ ओ)"

हालांकि आपका प्रश्न यह "सामान्य ओओ" के लिए इंगित करता है, यह वास्तव में इन शर्तों के एनएटी उपयोग पर ध्यान केंद्रित कर रहा है।

.NET (जावा के लिए समान) में:

  • इंटरफेस में कोई राज्य या कार्यान्वयन नहीं हो सकता
  • एक इंटरफ़ेस लागू करने वाला वर्ग उस इंटरफ़ेस के सभी तरीकों का कार्यान्वयन प्रदान करेगा
  • अमूर्त वर्गों में राज्य (डेटा सदस्य) और / या कार्यान्वयन (विधियां) हो सकते हैं
  • अमूर्त वर्गों को अमूर्त विधियों को लागू किए बिना विरासत में प्राप्त किया जा सकता है (हालांकि इस तरह के एक व्युत्पन्न वर्ग खुद में सार है)
  • इंटरफेस बहु-विरासत में हो सकते हैं, अमूर्त कक्षाएं नहीं हो सकतीं (शायद यह संभवतः एफ़्रेक्ट कक्षाओं से अलग होने के लिए इंटरफेस का महत्वपूर्ण ठोस कारण है – वे बहु-से अधिक विरासत के कार्यान्वयन की अनुमति देते हैं जो सामान्य एमआई की कई समस्याओं को हटा देता है)

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

दरअसल, गैर-वर्चुअल इंटरफ़ेस (एनवीआई) नामक सी ++ मुहावरे हैं, जहां सार्वजनिक विधियां गैर-वर्चुअल तरीके हैं जो निजी वर्चुअल विधियों के लिए 'थंब' हैं:

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

सभी यूएसएएफ पायलटों को कुछ वायु सेना-व्यापी नियमों का पालन करना पड़ता है, और सभी सी -141 (या एफ -16 या टी -38) पायलट 'यूएसएएफ पायलट' हैं। कोई भी सुरक्षा अधिकारी हो सकता है तो, संक्षेप में:

  • पायलट: अमूर्त वर्ग
  • सी -141 पायलट: ठोस वर्ग
  • आईएसएफटीए अधिकारी: इंटरफ़ेस

जोड़ा नोट: यह एक अवधारणा को समझाने में मदद करने के लिए एक सादृश्य होने का मतलब था, नहीं कोडिंग सिफारिश नीचे विभिन्न टिप्पणियां देखें, चर्चा दिलचस्प है।

मुझे लगता है कि वे जो जवाब तलाश रहे हैं वह मौलिक है या ओपॉस दार्शनिक अंतर है।

अमूर्त वर्ग उत्तराधिकार का उपयोग तब किया जाता है जब व्युत्पन्न वर्ग मूल गुणों और अमूर्त वर्ग के व्यवहार को साझा करता है। वास्तव में वर्ग को परिभाषित करने वाला व्यवहार

दूसरी ओर इंटरफ़ेस विरासत का उपयोग तब किया जाता है जब कक्षाएं परिधीय व्यवहार को साझा करती हैं, जो कि आवश्यक व्युत्पन्न वर्ग को परिभाषित नहीं करते हैं

उदाहरण के लिए एक कार और एक ट्रक एक ऑटोमोबाइल अमूर्त वर्ग के बहुत सारे मूल गुणों और व्यवहार को साझा करते हैं, लेकिन वे कुछ परिधीय व्यवहार भी साझा करते हैं जैसे निकास उत्पन्न होता है जो ड्रिलर्स या पावर जनरेटरों जैसे गैर ऑटोमोबाइल कक्षाओं को साझा करता है और यह कार या ट्रक को परिभाषित नहीं करता है , इसलिए कार, ट्रक, ड्रिलर और पावर जनरेटर सभी समान इंटरफेस IExhaust साझा कर सकते हैं।

संक्षिप्त: सार वर्गों को समान दिखने वाली कक्षाओं की श्रेणी के वर्गीकरण के मॉडलिंग के लिए उपयोग किया जाता है (उदाहरण के लिए पशु अमूर्त वर्ग और मानव, शेर, बाघ कंक्रीट व्युत्पन्न वर्ग हो सकते हैं)

तथा

अंतरफलक का प्रयोग 2 समान / गैर समान वर्गों के बीच संचार के लिए किया जाता है, जो वर्ग को लागू करने वाले इंटरफेस के प्रकार के बारे में परवाह नहीं करता है (जैसे ऊँचाई इंटरफ़ेस गुण हो सकती है और यह मानव, भवन, वृक्ष द्वारा कार्यान्वित किया जा सकता है। इससे कोई फर्क नहीं पड़ता कि आप खा सकते हैं , आप तैर सकते हैं कि आप मर सकते हैं या कुछ भी हो सकते हैं .. यह केवल एक चीज है जो आपको ऊँचाई (कार्यान्वयन वर्ग में क्रिया) करने की आवश्यकता है।

कुछ अन्य मतभेद हैं –

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

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

एपीआई को तोड़ने के बिना सार बेस क्लास को v2 + में संशोधित किया जा सकता है। इंटरफेस में परिवर्तन परिवर्तन तोड़ रहे हैं

[सी # /। नेट विशिष्ट] इंटरफेस, मूल आधार वर्गों के विपरीत, मूल्य प्रकार (स्ट्रैक्ट्स) पर लागू किया जा सकता है। सार अमूर्त आधार कक्षाओं से वारिस नहीं कर सकते। यह मूल्य के प्रकारों पर व्यवहार अनुबंध / उपयोग दिशानिर्देश लागू करने की अनुमति देता है।

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

 public class Vehicle { private Driver driver; private Seat[] seatArray; //In java and most of the Object Oriented Programming(OOP) languages, square brackets are used to denote arrays(Collections). //You can define as many properties as you want here.. } 

अब एक साइकिल ..

 public class Bicycle extends Vehicle { //You define properties which are unique to bicycles here.. private Pedal pedal; } 

और एक कार ..

 public class Car extends Vehicle { private Engine engine; private Door[] doors; } 

यह विरासत के बारे में सब कुछ है हम उन वस्तुओं का वर्गीकरण सरल आधार रूपों और उनके बच्चों में वर्गीकृत करने के लिए करते हैं जैसे हमने ऊपर देखा

सार क्लासेस

सार कक्षाएं अपूर्ण वस्तुएं हैं। इसे आगे समझने के लिए, एक बार फिर वाहन के समानता पर विचार करें।
एक वाहन संचालित किया जा सकता है सही? लेकिन अलग-अलग वाहन अलग-अलग तरीकों से संचालित होते हैं .. उदाहरण के लिए, आप एक साइकिल चलाते ही कार चला सकते हैं।
तो एक वाहन के ड्राइव फ़ंक्शन का प्रतिनिधित्व कैसे करें? यह किस प्रकार के वाहन की जांच करना कठिन है और इसे अपने स्वयं के कार्य से चलाया जा सकता है; आपको एक नए प्रकार के वाहन को जोड़ते समय दोबारा ड्राइवर वर्ग को बदलना होगा।
यहाँ सार वर्गों और तरीकों की भूमिका है। आप यह बता सकते हैं कि हर विरासत वाले बच्चों को इस फ़ंक्शन को लागू करना चाहिए।
तो अगर आप वाहन वर्ग को संशोधित करते हैं ..

 //......Code of Vehicle Class abstract public void drive(); //.....Code continues 

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

इंटरफेस इंटरफेस पूरी तरह से अधूरे हैं। उनके पास कोई गुण नहीं है वे सिर्फ इंगित करते हैं कि इनहेरिटिंग बच्चे कुछ करने में सक्षम हैं ..
मान लें कि आपके पास विभिन्न प्रकार के मोबाइल फोन हैं उनमें से प्रत्येक के विभिन्न कार्य करने के लिए अलग-अलग तरीके हैं; पूर्व: किसी व्यक्ति को कॉल करें फोन के निर्माता निर्दिष्ट करता है कि यह कैसे करना है। यहां मोबाइल फोन नंबर डायल कर सकते हैं – अर्थात यह डायल-सक्षम है। आइए इसे एक अंतरफलक के रूप में दर्शाएं।

 public interface Dialable { public void dial(Number n); } 

यहां डायल करने वाला निर्माता परिभाषित करता है कि कैसे कोई संख्या डायल करें। आपको इसे डायल करने के लिए नंबर देना होगा।

 Dialable myPhone1 = new Dialable() { public void dial(Number n) { //Do the phone1's own way to dial a number } } Dialable myPhone2 = new Dialable() { public void dial(Number n) { //Do the phone2's own way to dial a number } } 

अमूर्त कक्षाओं के बजाय इंटरफेस का उपयोग करके, आपको इसके गुणों के बारे में चिंता करने की आवश्यकता नहीं है। पूर्व: क्या इसमें एक टच स्क्रीन या डायल पैड है, क्या यह एक निश्चित लैंडलाइन फोन या मोबाइल फोन है आपको यह जानना होगा कि यह डायल करने योग्य है या नहीं; क्या यह डायलएबल इंटरफ़ेस (या कार्यान्वयन) वारिस करता है?
इंटरफेस आमतौर पर डेवलपर्स द्वारा उपयोग किए जाते हैं, ताकि ऑब्जेक्ट्स के बीच इंटरऑपरेबिलिटी (एक दूसरे का प्रयोग करें) सुनिश्चित हो सके, जहां तक ​​वे एक सामान्य फ़ंक्शन साझा करते हैं (जैसे कि आप किसी लैंडलाइन या मोबाइल फोन में बदल सकते हैं, जहां तक ​​आपको नंबर डायल करना है)। संक्षेप में, इंटरफेस किसी भी संपत्ति के बिना, सार कक्षाओं का बहुत सरल संस्करण है।
यह भी ध्यान रखें कि आप चाहते हैं कि आप के रूप में कई इंटरफेस कार्यान्वित कर सकते हैं (लेकिन) लेकिन आप केवल एक ही पैरेंट क्लास को बढ़ा सकते हैं

अधिक जानकारी सार कक्षा बनाम इंटरफेस

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

ओरेकल वेबसाइट interface और abstract वर्ग के बीच महत्वपूर्ण अंतर प्रदान करता है।

अमूर्त कक्षाओं का उपयोग करने पर विचार करें यदि:

  1. आप कई बारीकी से संबंधित कक्षाओं के बीच कोड साझा करना चाहते हैं।
  2. आप अपेक्षा करते हैं कि आपके अमूर्त वर्ग का विस्तार करने वाले वर्ग में कई सामान्य विधियां या फ़ील्ड हैं, या सार्वजनिक (जैसे सुरक्षित और निजी) के अलावा अन्य पहुंच संशोधक की आवश्यकता होती है।
  3. आप गैर-स्थिर या गैर-अंतिम क्षेत्रों को घोषित करना चाहते हैं

इंटरफेस का उपयोग करने पर विचार करें यदि:

  1. आप अपेक्षा करते हैं कि असंबंधित वर्ग आपके इंटरफ़ेस को कार्यान्वित करेगा। उदाहरण के लिए, कई असंबंधित ऑब्जेक्ट Serializable इंटरफ़ेस को लागू कर सकते हैं।
  2. आप किसी विशेष डेटा प्रकार के व्यवहार को निर्दिष्ट करना चाहते हैं, लेकिन इसके व्यवहार के बारे में चिंतित नहीं।
  3. आप कई प्रकार के विरासत का लाभ लेना चाहते हैं।

सरल शब्दों में, मैं उपयोग करना चाहूंगा

इंटरफ़ेस: कई असंबंधित वस्तुओं द्वारा एक अनुबंध को लागू करने के लिए

अमूर्त वर्ग: एकाधिक संबंधित वस्तुओं के बीच समान या भिन्न व्यवहार को लागू करना

स्पष्ट रूप से चीजों को समझने के लिए कोड उदाहरण पर एक नज़र डालें: एक अंतरफलक और एक सार वर्ग के बीच अंतर को कैसे समझाया?

इंटरफेस को कार्यान्वित करके आप विरासत के बजाय संरचना प्राप्त कर रहे हैं ("है-ए" रिश्ते) यह याद रखने के लिए एक महत्वपूर्ण सिद्धांत है कि जब डिजाइन पैटर्न जैसे चीजों की बात आती है, जहां आपको विरासत के बजाय व्यवहारों की संरचना प्राप्त करने के लिए इंटरफेस का उपयोग करने की आवश्यकता होती है

साक्षात्कारकर्ता एक विषम वृक्ष को भौंक कर रहे हैं। सी # और जावा जैसी भाषाओं के लिए, एक अंतर है, लेकिन सी ++ जैसी अन्य भाषाओं में नहीं है। ओ ओ सिद्धांत दो को अंतर नहीं करता, केवल भाषा का सिंटैक्स

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

सी # या जावा में किसी भी कार्यान्वयन के बिना एक अमूर्त वर्ग केवल इंटरैक्शन से अलग होता है जो इसे से वारिस के लिए इस्तेमाल किया जाता है और इस तथ्य से कि आप केवल एक से प्राप्त कर सकते हैं

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

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

    अगर आप कार्यान्वयन के बारे में नहीं जानते हैं तो हमारे पास आवश्यकता विनिर्देश है तो हम इंटरफ़ेस के साथ जाते हैं

  2. जब हमें सार कक्षा का इस्तेमाल करना चाहिए?

    अगर आप क्रियान्वयन जानते हैं लेकिन पूरी तरह से (आंशिक रूप से कार्यान्वयन) नहीं करते तो हम सार कक्षा के साथ जाते हैं।

    इंटरफेस

    डिफ़ॉल्ट पद्धति के अनुसार हर पद्धति का मतलब इंटरफ़ेस 100% शुद्ध सार है।

    सार

    कंक्रीट पद्धति और सार विधि हो सकते हैं, जो कंक्रीट विधि है, जो कि सार कक्षा में कार्यान्वित है, एक सार वर्ग एक ऐसा वर्ग है जिसे सार घोषित किया गया है- यह सार विधियों में शामिल हो सकता है या इसमें शामिल नहीं हो सकता है।

    इंटरफेस

    हम इंटरफ़ेस को एक निजी, संरक्षित के रूप में घोषित नहीं कर सकते

    प्रश्न: हम इंटरफेस को एक निजी और संरक्षित क्यों नहीं घोषित कर रहे हैं?

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

    इंटरफ़ेस विधि
    हम भी इंटरफ़ेस को निजी, संरक्षित, अंतिम, स्थिर, सिंक्रनाइज़, देशी के रूप में नहीं घोषित कर सकते हैं …..

    मैं इसका कारण बताऊंगा: हम सिंक्रनाइज़ किए गए विधि को क्यों नहीं घोषित कर रहे हैं क्योंकि हम इंटरफ़ेस का ऑब्जेक्ट नहीं बना सकते हैं और सिंक्रनाइज़ ऑब्जेक्ट पर काम कर सकते हैं और बेटा कारण है कि हम सिंक्रनाइज़ किए गए विधि की घोषणा नहीं कर रहे हैं अस्थायी अवधारणा भी लागू नहीं है क्योंकि तुल्यकालन के साथ क्षणिक काम।

    सार

    हम खुशी से सार्वजनिक, निजी अंतिम स्थैतिक के साथ उपयोग करते हैं …. इसका अर्थ है कि कोई भी प्रतिबंध सार में लागू नहीं है।

    इंटरफेस

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

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

    और वाष्पशील चर परिवर्तनों पर रहना है, इसलिए यह opp है अंतिम करने के लिए यही वजह है कि हम अंतरफलक में वाष्पशील चर का उपयोग नहीं कर रहे हैं।

    सार

    सार परिवर्तनीय को सार्वजनिक स्थिर अंतिम घोषित करने की आवश्यकता नहीं है।

मुझे उम्मीद है कि यह लेख उपयोगी है।

नेट के लिए,

आपका दूसरा साक्षात्कारकर्ता का जवाब भी पहले एक का जवाब है … सार कक्षाएं कार्यान्वयन, और राज्य, इंटरफेस नहीं कर सकते हैं …

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

संकल्पनात्मक रूप से बोलना, भाषा विशिष्ट कार्यान्वयन, नियम, लाभ और किसी भी या दोनों का उपयोग करके किसी भी प्रोग्रामिंग लक्ष्य को प्राप्त करना, कोड / डेटा / संपत्ति, ब्ला ब्ला, सिंगल या एकाधिक वंशानुक्रम, सब कुछ

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

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

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

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

मेरा मानना ​​है कि दोनों साक्षात्कारकर्ता इन दोनों के बीच एक पंक्ति की सीधे सीधा अंतर की अपेक्षा कर रहे थे और जब आप असफल रहे, तो उन्हें एक को दूसरे के रूप में लागू करके आपको इस अंतर की ओर आकर्षित करने की कोशिश की

क्या होगा अगर आपके पास केवल सार विधियों के साथ एक सार वर्ग था?

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

इंटरफ़ेस: एक अनुबंध को सुनिश्चित करने के लिए और अधिक बनाए रखने योग्य, स्केलेबल और परीक्षण योग्य अनुप्रयोग के लिए कक्षाओं के बीच कम युग्मन करने के लिए उपयोग किया जाता है।

अमूर्त वर्ग: केवल उसी उत्तरदायित्व की कक्षाओं के बीच कुछ कोड को घटाना है। ध्यान दें कि यह मुख्य कारण है कि OOP में बहु-विरासत एक बुरी चीज है, क्योंकि एक क्लास को कई जिम्मेदारियों को नहीं संभालना चाहिए (इसके बजाय संयोजन का उपयोग करें)।

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

 After all that, the interviewer came up with the question "What if you had an Abstract class with only abstract methods? How would that be different from an interface?" 

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

 An another interviewer asked me what if you had a Public variable inside the interface, how would that be different than in Abstract Class? 

इंटरफेस में वेरिएबल डिफ़ॉल्ट रूप से सार्वजनिक स्थिर और अंतिम हैं प्रश्न बन सकते हैं जैसे कि अमूर्त वर्ग के सभी चर सार्वजनिक हैं? वैसे भी वे अभी भी गैर स्थिर और गैर अंतिम इंटरफेस में चर के विपरीत हो सकता है।

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

  1. इंटरफेस:
    • हम (या परिभाषित) विधियों को लागू नहीं करते हैं, हम इसे व्युत्पन्न कक्षाओं में करते हैं।
    • हम इंटरफेस में सदस्य चर घोषित नहीं करते हैं।
    • इंटरफेस एचएएस-ए रिश्ते को व्यक्त करते हैं इसका मतलब है कि वे वस्तुओं का एक मुखौटा है
  2. सार वर्ग:
    • हम अमूर्त वर्ग में विधियों को घोषित और परिभाषित कर सकते हैं।
    • हम इसके कन्स्ट्रक्टर को छिपाते हैं इसका मतलब है कि इसका कोई उद्देश्य प्रत्यक्ष रूप से निर्मित नहीं है
    • सार वर्ग सदस्य चर पकड़ सकता है।
    • व्युत्पन्न वर्ग अमूर्त वर्ग के लिए उत्तीर्ण होते हैं जिसका मतलब है कि व्युत्पन्न कक्षाओं से वस्तुओं को नकाबपोश नहीं किया गया है, यह सार वर्ग के लिए उत्तीर्ण होता है। इस मामले में रिश्ते आईएस-ए है

ये मेरा विचार हे।

जेफरी रिचटर द्वारा सी # के माध्यम से सीएलआर से कॉपी किया गया …

मैं अक्सर सवाल सुनता हूं, "क्या मुझे बेस प्रकार या इंटरफ़ेस डिज़ाइन करना चाहिए?" जवाब हमेशा स्पष्ट नहीं होता है

यहां कुछ दिशानिर्देश दिए गए हैं जो आपकी मदद कर सकते हैं:

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

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

■■ लगातार कार्यान्वयन कोई भी अंतरफलक अनुबंध को कितनी अच्छी तरह प्रलेखित नहीं किया गया है, यह बहुत कम संभावना नहीं है कि हर कोई अनुबंध 100 प्रतिशत सही तरीके से लागू करेगा In fact, COM suffers from this very problem, which is why some COM objects work correctly only with Microsoft Word or with Windows Internet Explorer. By providing a base type with a good default implementation, you start off using a type that works and is well tested; you can then modify parts that need modification.

■■ Versioning If you add a method to the base type, the derived type inherits the new method, you start off using a type that works, and the user's source code doesn't even have to be recompiled. Adding a new member to an interface forces the inheritor of the interface to change its source code and recompile.

Difference between Java Interface and Abstract Class

  1. Main difference is methods of a Java interface are implicitly abstract and cannot have implementations. A Java abstract class can have instance methods that implements a default behavior.

  2. Variables declared in a Java interface is by default final. An abstract class may contain non-final variables.

  3. Members of a Java interface are public by default. A Java abstract class can have the usual flavors of class members like private, protected, etc..

  4. Java interface should be implemented using keyword “implements”; A Java abstract class should be extended using keyword “extends”.

  5. An interface can extend another Java interface only, an abstract class can extend another Java class and implement multiple Java interfaces.

  6. A Java class can implement multiple interfaces but it can extend only one abstract class.

  7. Interface is absolutely abstract and cannot be instantiated; A Java abstract class also cannot be instantiated, but can be invoked if a main() exists.

  8. In comparison with java abstract classes, java interfaces are slow as it requires extra indirection.

Most answers focus on the technical difference between Abstract Class and Interface, but since technically, an interface is basically a kind of abstract class (one without any data or implementation), I think the conceptual difference is far more interesting, and that might be what the interviewers are after.

An Interface is an agreement . It specifies: "this is how we're going to talk to each other". It can't have any implementation because it's not supposed to have any implementation. It's a contract. It's like the .h header files in C.

An Abstract Class is an incomplete implementation . A class may or may not implement an interface, and an abstract class doesn't have to implement it completely. An abstract class without any implementation is kind of useless, but totally legal.

Basically any class, abstract or not, is about what it is , whereas an interface is about how you use it . For example: Animal might be an abstract class implementing some basic metabolic functions, and specifying abstract methods for breathing and locomotion without giving an implementation, because it has no idea whether it should breathe through gills or lungs, and whether it flies, swims, walks or crawls. Mount , on the other hand, might be an Interface, which specifies that you can ride the animal, without knowing what kind of animal it is (or whether it's an animal at all!).

The fact that behind the scenes, an interface is basically an abstract class with only abstract methods, doesn't matter. Conceptually, they fill totally different roles.

Abstract class And Interface Difference :

  1. Abstract class can have abstract and non-abstract methods and Interface can have only abstract methods.
  2. Abstract class doesn't support multiple inheritance And Interface supports multiple inheritance.
  3. Abstract class can have final, non-final, static and non-static variables And Interface has only static and final variables.
  4. Abstract class can have static methods, main method and constructor And Interface can't have static methods, main method or constructor.
  5. Abstract class can provide the implementation of interface And Interface can't provide the implementation of abstract class.
  6. The abstract keyword is used to declare abstract class And The interface keyword is used to declare interface.
  7. Abstract class achieves partial abstraction (0 to 100%) because there are non abstract methods also in abstract class whereas interface achieves fully abstraction (100%).

Interfaces are light weight way to enforce a particular behavior. That is one way to think of.

An interface defines a contract for a service or set of services. They provide polymorphism in a horizontal manner in that two completely unrelated classes can implement the same interface but be used interchangeably as a parameter of the type of interface they implement, as both classes have promised to satisfy the set of services defined by the interface. Interfaces provide no implementation details.

An abstract class defines a base structure for its sublcasses, and optionally partial implementation. Abstract classes provide polymorphism in a vertical, but directional manner, in that any class that inherits the abstract class can be treated as an instance of that abstract class but not the other way around. Abstract classes can and often do contain implementation details, but cannot be instantiated on their own- only their subclasses can be "newed up".

C# does allow for interface inheritance as well, mind you.

1) An interface can be seen as a pure Abstract Class, is the same, but despite this, is not the same to implement an interface and inheriting from an abstract class. When you inherit from this pure abstract class you are defining a hierarchy -> inheritance, if you implement the interface you are not, and you can implement as many interfaces as you want, but you can only inherit from one class.

2) You can define a property in an interface, so the class that implements that interface must have that property.

उदाहरण के लिए:

  public interface IVariable { string name {get; set;} } 

The class that implements that interface must have a property like that.

As you might have got the theoretical knowledge from the experts, I am not spending much words in repeating all those here, rather let me explain with a simple example where we can use/cannot use Interface and Abstract class .

Consider you are designing an application to list all the features of Cars. In various points you need inheritance in common, as some of the properties like DigitalFuelMeter, Air Conditioning, Seat adjustment, etc are common for all the cars. Likewise, we need inheritance for some classes only as some of the properties like the Braking system (ABS,EBD) are applicable only for some cars.

The below class acts as a base class for all the cars:

 public class Cars { public string DigitalFuelMeter() { return "I have DigitalFuelMeter"; } public string AirCondition() { return "I have AC"; } public string SeatAdjust() { return "I can Adjust seat"; } } 

Consider we have a separate class for each Cars.

 public class Alto : Cars { // Have all the features of Car class } public class Verna : Cars { // Have all the features of Car class + Car need to inherit ABS as the Braking technology feature which is not in Cars } public class Cruze : Cars { // Have all the features of Car class + Car need to inherit EBD as the Braking technology feature which is not in Cars } 

Consider we need a method for inheriting the Braking technology for the cars Verna and Cruze (not applicable for Alto). Though both uses braking technology, the "technology" is different. So we are creating an abstract class in which the method will be declared as Abstract and it should be implemented in its child classes.

 public abstract class Brake { public abstract string GetBrakeTechnology(); } 

Now we are trying to inherit from this abstract class and the type of braking system is implemented in Verna and Cruze:

 public class Verna : Cars,Brake { public override string GetBrakeTechnology() { return "I use ABS system for braking"; } } public class Cruze : Cars,Brake { public override string GetBrakeTechnology() { return "I use EBD system for braking"; } } 

See the problem in the above two classes? They inherit from multiple classes which C#.Net doesn't allow even though the method is implemented in the children. Here it comes the need of Interface.

 interface IBrakeTechnology { string GetBrakeTechnology(); } 

And the implementation is given below:

 public class Verna : Cars, IBrakeTechnology { public string GetBrakeTechnology() { return "I use ABS system for braking"; } } public class Cruze : Cars, IBrakeTechnology { public string GetBrakeTechnology() { return "I use EBD system for braking"; } } 

Now Verna and Cruze can achieve multiple inheritance with its own kind of braking technologies with the help of Interface.

From another answer of mine , mostly dealing with when to use one versus the other:

In my experience, interfaces are best used when you have several classes which each need to respond to the same method or methods so that they can be used interchangeably by other code which will be written against those classes' common interface. The best use of an interface is when the protocol is important but the underlying logic may be different for each class. If you would otherwise be duplicating logic, consider abstract classes or standard class inheritance instead.

Though this question is quite old, I would like to add one other point in favor of interfaces:

Interfaces can be injected using any Dependency Injection tools where as Abstract class injection supported by very few.

Interface : should be used if you want to imply a rule on the components which may or may not be related to each other

पेशेवरों:

  1. Allows multiple inheritance
  2. Provides abstraction by not exposing what exact kind of object is being used in the context
  3. provides consistency by a specific signature of the contractInterface:
  4. Allows multiple inheritance
  5. Provides abstraction by not exposing what exact kind of object is being used in the context
  6. Provides consistency by a specific signature of the contract

विपक्ष:

  1. Must implement all the contracts defined
  2. Cannot have variables or delegates
  3. Once defined cannot be changed without breaking all the classes

Abstract Class : should be used where you want to have some basic or default behaviour or implementation for components related to each other

पेशेवरों:

  1. Faster then interface
  2. Has flexibility in the implementation (you can implement it fully or partially)
  3. Can be easily changed without breaking the derived classes

विपक्ष:

  1. Cannot be instantiated
  2. Does not support multiple inheritance

Interface Types vs. Abstract Base Classes

Adapted from the Pro C# 5.0 and the .NET 4.5 Framework book.

The interface type might seem very similar to an abstract base class. Recall that when a class is marked as abstract, it may define any number of abstract members to provide a polymorphic interface to all derived types. However, even when a class does define a set of abstract members, it is also free to define any number of constructors, field data, nonabstract members (with implementation), and so on. Interfaces, on the other hand, contain only abstract member definitions. The polymorphic interface established by an abstract parent class suffers from one major limitation in that only derived types support the members defined by the abstract parent. However, in larger software systems, it is very common to develop multiple class hierarchies that have no common parent beyond System.Object. Given that abstract members in an abstract base class apply only to derived types, we have no way to configure types in different hierarchies to support the same polymorphic interface. By way of example, assume you have defined the following abstract class:

 public abstract class CloneableType { // Only derived types can support this // "polymorphic interface." Classes in other // hierarchies have no access to this abstract // member. public abstract object Clone(); } 

Given this definition, only members that extend CloneableType are able to support the Clone() method. If you create a new set of classes that do not extend this base class, you can't gain this polymorphic interface. Also, you might recall that C# does not support multiple inheritance for classes. Therefore, if you wanted to create a MiniVan that is-a Car and is-a CloneableType, you are unable to do so:

 // Nope! Multiple inheritance is not possible in C# // for classes. public class MiniVan : Car, CloneableType { } 

As you would guess, interface types come to the rescue. After an interface has been defined, it can be implemented by any class or structure, in any hierarchy, within any namespace or any assembly (written in any .NET programming language). As you can see, interfaces are highly polymorphic. Consider the standard .NET interface named ICloneable, defined in the System namespace. This interface defines a single method named Clone():

 public interface ICloneable { object Clone(); } 

For sure it is important to understand the behaviour of interface and abstract class in OOP (and how languages handle them), but I think it is also important to understand what exactly each term mean. Can you imagine the if command not working exactly as the meaning of the term? Also, actually some languages are reducing even more the differences between interface and abstract… if by chance one day the two terms operate almost identically, at least you can define yourself where (and why) should any of them be used for.

If you read through some dictionaries and other fonts you may find different meanings for a same term but having some common definitions. I think these two meanings I found in this site are really, really good and suitable.

इंटरफेस:

A thing or circumstance that enables separate and sometimes incompatible elements to coordinate effectively.

सार:

Something that concentrates in itself the essential qualities of anything more extensive or more general, or of several things; essence.

उदाहरण:

You bought a car and it needs fuel.

यहां छवि विवरण दर्ज करें

Your car model is XYZ , so it is a concrete car, a specific instance of a car. A car is not a real object. In fact, it is an abstract set of standards (qualities) to create a specific object. In short, Car is an abstract class , it is "something that concentrates in itself the essential qualities of anything more extensive or more general" .

Only fuel that matches the car manual specification should be used to fill up the car tank. Actually, you can fill up with anything you want but, in fact, the engine will only work properly with the specified fuel, so it is better to follow its requirements. The requirements says that it accepts, as other cars of the same genre ABC , a standard set of fuel.

In an Object Oriented view, fuel for genre ABC should not be declared as a concrete class because there is no real fuel like this out there. Although you could accept an abstract class Fuel or VehicularFuel, you must remember that your car only accept some of the existing vehicular fuel, those that implements the requirements in your car manual. In short, they should implement the interface ABCGenreFuel , which "… enables separate and sometimes incompatible elements to coordinate effectively" .

Addendum

In addition, I think you should keep in mind the meaning of the term class, which is (from the same site previously mentioned):

वर्ग:

A number of persons or things regarded as forming a group by reason of common attributes, characteristics, qualities, or traits; kind;

This way, a class (or abstract class) should not represent only common attributes (like an interface), but some kind of group with common attributes. An interface doesn't need to represent a kind. It must represent common attributes. This way, I think classes and abstract classes may be used to represent things that should not change its aspects often, like a HumanBeing being a Mammal, because it represents some kinds. Kinds should not change themselves that often.

Couple of other differences:

Abstract classes can have static methods, properties, fields etc. and operators, interfaces can't. Cast operator allows casting to/from abstract class but don't allow casting to/from interface.

So pretty much you can use abstract class on its own even if it is never implemented (through its static members) and you can't use interface on its own in any way.

Interface:- == contract.Whichever class implements it has to follow all the specification of interface.

A real-time example would be any ISO marked Product. ISO gives set of rules/specification on how the product should be build and what minimum set of features it Must have.

This is nothing but subset of properties product Must have.ISO will sign the product only if it satisfies the its standards .

Now take a look at this code

 public interface IClock{ //defines a minimum set of specification which a clock should have public abstract Date getTime(); public abstract int getDate(); } public class Fasttrack: Clock { // Must have getTime() and getTime() as it implements IClock // It also can have other set of feature like public void startBackgroundLight() { // watch with internal light in it. } .... //Fastrack can support other feature as well .... .... } 

Here a Fastrack is called as watch because it has all that features that a watch must suppost ( Minimum set of features ).

Why and When Abstract:

From MSDN:

The purpose of an abstract class is to provide a common definition of a base class that multiple derived classes can share.

For example, a class library may define an abstract class that is used as a parameter to many of its functions, and require programmers using that library to provide their own implementation of the class by creating a derived class. Abstract simply means if you cannot define it completely declare it as an abstract .Implementing class will complete this implementation.

Eg -: Suppose I declare a Class Recipe as abstract but I dont know which recipe to be made.Then I will generalize this class to define the common definition of any recipe .The implantation of recipe will depend on implementing dish.

Abstract class can consist of abstract methods as well as not abstract method So you can notice the difference in Interface.So not necessarily every method your implementing class must have.You only need to override the abstract methods.

In Simple words If you want tight coupling use Interface o/w use in case of lose coupling Abstract Class