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

Question

कृपया भाषा को समझने के लिए एक आसान या किसी लेख की एक कड़ी में व्याख्या करें।

Comments

लिंक इस उदाहरण ने इंटरफ़ेस और अमूर्त वर्ग के बारे में कुछ समझ आसानी से लागू की और लागू होती है और जावा में फैली हुई है।

— यूजर लर्निंग

Answer 1

extendsएक वर्ग का विस्तार करने के लिए है ।

implementsएक इंटरफ़ेस लागू करने के लिए है

एक इंटरफ़ेस और एक नियमित वर्ग के बीच का अंतर यह है कि एक इंटरफ़ेस में आप किसी भी घोषित तरीकों को लागू नहीं कर सकते हैं। केवल वह वर्ग जो इंटरफ़ेस को "लागू करता है" विधियों को लागू कर सकता है। एक इंटरफ़ेस के C ++ समतुल्य एक सार वर्ग होगा (बिल्कुल वैसा ही नहीं बल्कि बहुत अधिक)।

इसके अलावा जावा कक्षाओं के लिए कई विरासत का समर्थन नहीं करता है । यह कई इंटरफेस का उपयोग करके हल किया गया है।

 public interface ExampleInterface {
    public void doAction();
    public String doThis(int number);
 }

 public class sub implements ExampleInterface {
     public void doAction() {
       //specify what must happen
     }

     public String doThis(int number) {
       //specfiy what must happen
     }
 }

अब एक वर्ग का विस्तार

 public class SuperClass {
    public int getNb() {
         //specify what must happen
        return 1;
     }

     public int getNb2() {
         //specify what must happen
        return 2;
     }
 }

 public class SubClass extends SuperClass {
      //you can override the implementation
      @Override
      public int getNb2() {
        return 3;
     }
 }

इस मामले में

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

मेरा सुझाव है कि आप गतिशील बंधन, बहुरूपता और वस्तु-उन्मुख प्रोग्रामिंग में सामान्य विरासत पर कुछ और शोध करें

Comments

एक इंटरफ़ेस में विधि घोषणाओं से अधिक तरीका हो सकता है: लगातार क्षेत्र, एनोटेशन, इंटरफेस और यहां तक ​​कि कक्षाएं।

— फिलिप रीचर्ट

क्या वे रूबी में मॉड्यूल और मिश्रण जैसे कुछ हैं?

— user2492854

@ user2492854 थोड़ा सा, लेकिन एक इंटरफ़ेस में कोई कार्यान्वित तरीके नहीं होंगे। यह सचमुच एक इंटरफ़ेस का वर्णन है, कार्यान्वयन नहीं।

— रॉब

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

— ADTC

"विस्तार एक वर्ग का विस्तार करने के लिए है", थोड़ा भ्रमित है। एक इंटरफ़ेस साइन करें और एक इंटरफ़ेस भी बढ़ाएँ । उदाहरण के लिए:public interface ListIterator<E> extends Iterator<E>

— weiheng

Answer 2

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

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

Answer 3

आम तौर पर लागू एक को लागू करने के लिए इस्तेमाल किया इंटरफ़ेस और फैली के लिए इस्तेमाल किया विस्तार आधार वर्ग व्यवहार या की अमूर्त वर्ग।

विस्तार : एक व्युत्पन्न वर्ग एक आधार वर्ग का विस्तार कर सकता है। आप एक स्थापित संबंध के व्यवहार को फिर से परिभाषित कर सकते हैं। व्युत्पन्न वर्ग " एक " बेस क्लास प्रकार है

औजार : आप एक अनुबंध लागू कर रहे हैं। इंटरफ़ेस को लागू करने वाले वर्ग में एक "क्षमता" है।

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

उनमें से प्रत्येक का उपयोग करने के लिए इस प्रश्न का संदर्भ लें:

इंटरफ़ेस बनाम सार वर्ग (सामान्य ऊ)

चीजों को समझने के लिए उदाहरण।

public class ExtendsAndImplementsDemo{
    public static void main(String args[]){

        Dog dog = new Dog("Tiger",16);
        Cat cat = new Cat("July",20);

        System.out.println("Dog:"+dog);
        System.out.println("Cat:"+cat);

        dog.remember();
        dog.protectOwner();
        Learn dl = dog;
        dl.learn();

        cat.remember();
        cat.protectOwner();

        Climb c = cat;
        c.climb();

        Man man = new Man("Ravindra",40);
        System.out.println(man);

        Climb cm = man;
        cm.climb();
        Think t = man;
        t.think();
        Learn l = man;
        l.learn();
        Apply a = man;
        a.apply();

    }
}

abstract class Animal{
    String name;
    int lifeExpentency;
    public Animal(String name,int lifeExpentency ){
        this.name = name;
        this.lifeExpentency=lifeExpentency;
    }
    public void remember(){
        System.out.println("Define your own remember");
    }
    public void protectOwner(){
        System.out.println("Define your own protectOwner");
    }

    public String toString(){
        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
    }
}
class Dog extends Animal implements Learn{

    public Dog(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " will protect owner");
    }
    public void learn(){
        System.out.println(this.getClass().getSimpleName()+ " can learn:");
    }
}
class Cat extends Animal implements Climb {
    public Cat(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
    }
    public void climb(){
        System.out.println(this.getClass().getSimpleName()+ " can climb");
    }
}
interface Climb{
    public void climb();
}
interface Think {
    public void think();
}

interface Learn {
    public void learn();
}
interface Apply{
    public void apply();
}

class Man implements Think,Learn,Apply,Climb{
    String name;
    int age;

    public Man(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void think(){
        System.out.println("I can think:"+this.getClass().getSimpleName());
    }
    public void learn(){
        System.out.println("I can learn:"+this.getClass().getSimpleName());
    }
    public void apply(){
        System.out.println("I can apply:"+this.getClass().getSimpleName());
    }
    public void climb(){
        System.out.println("I can climb:"+this.getClass().getSimpleName());
    }
    public String toString(){
        return "Man :"+name+":Age:"+age;
    }
}

उत्पादन:

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

समझने के लिए महत्वपूर्ण बिंदु:

1. कुत्ते और बिल्ली जानवर हैं और वे बढ़ाया remember() और protectOwner() साझा करने से name,lifeExpentencyसेAnimal
2. बिल्ली चढ़ सकती है () लेकिन डॉग नहीं। कुत्ता सोच सकता है () लेकिन बिल्ली नहीं । इन विशिष्ट क्षमताओं को उस क्षमता को लागू करने Catऔर उनके Dogद्वारा जोड़ा जाता है।
3. मनुष्य एक जानवर नहीं है लेकिन वह कर सकता है Think,Learn,Apply,Climb

इन उदाहरणों से गुजरकर, आप समझ सकते हैं

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

Comments

बहुत अच्छी तरह से समझाया गया। यह बस क्लिक किया। बहुत बहुत धन्यवाद!

— अमीर मेमोरियल

क्या वाकई ऐसा है? मैं हमेशा सोचता था "एक" कुछ होने के लिए संदर्भित करता है, इसके पास है। आप कह सकते हैं कि बिल्ली की "चढ़ने की क्षमता" है, लेकिन मैं कहूंगा कि आपके उदाहरण को फिर से प्रस्तुत करना होगा। कैट "एक" क्लाइंबर "है, मनुष्य" एक "" विचारक, सीखने वाला, पर्वतारोही है। "चूंकि आदमी" एक "विचारक" है, वह एक विचारक जो कर सकता है वह कर सकता है। कुछ प्रोटोकॉल के साथ काम करने पर यह और भी स्पष्ट है - यदि आप एक घर है, इसका एक दरवाजा है, लेकिन यह पुशहैंडल को लागू नहीं करता है। यह भी एक "MaterialObject है, जिसका अर्थ है कि यह गुरुत्वाकर्षण का पालन करने के लिए इंटरफ़ेस लागू करता है; इसमें" GravityObeyingSkill "या ऐसा ही कुछ नहीं है।

— मैथोरॉक

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

— रवींद्र बाबू

@Ravindrababu इतने स्पष्ट स्पष्टीकरण के लिए बहुत धन्यवाद।

— कानोडो

महान समझाया!

— डरी जूल

Answer 4

extendsतब के लिए है जब आप बेस क्लास से विरासत में प्राप्त कर रहे हैं (यानी इसकी कार्यक्षमता बढ़ा रहे हैं)।

implementsजब आप एक इंटरफ़ेस लागू कर रहे हों, तब के लिए ।

यहां शुरू करने के लिए एक अच्छी जगह है: इंटरफेस और विरासत ।

Comments

और जब आप एक इंटरफ़ेस का विस्तार कर रहे हैं, तो इसका विस्तार :-) भी है।

— मार्क पीटर्स

Answer 5

A classकेवल "कार्यान्वित" कर सकता है a interface। एक वर्ग केवल "विस्तार" करता है class। इसी तरह, एक interfaceऔर विस्तार कर सकते हैंinterface ।

A classकेवल एक दूसरे का विस्तार कर सकता है class। A classकई को कार्यान्वित कर सकता हैinterface एस ।

यदि इसके बजाय आपको abstract classएस और interfaceएस का उपयोग करने के बारे में जानने में अधिक रुचि है , तो इस धागे को देखें: इंटरफ़ेस बनाम एब्स्ट्रैक्ट क्लास (सामान्य ऊ)

Comments

आप एक इंटरफ़ेस भी बढ़ा सकते हैं।

— मार्क पीटर्स

A classकेवल एक को लागू कर सकता है interface। A classकई अन्य वर्गों का विस्तार कर सकता है। मेरा मानना ​​है कि आप इस पीछे की ओर बढ़ गए हैं।

— pb2q

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

— वारबंकी

Answer 6

एक इंटरफ़ेस उन कार्यों का वर्णन है जो एक वस्तु कर सकती है ... उदाहरण के लिए जब आप एक प्रकाश स्विच को फ्लिप करते हैं, तो प्रकाश चलता है, आप परवाह नहीं करते कि कैसे, बस यही करता है। ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में, एक इंटरफ़ेस उन सभी कार्यों का विवरण है जो एक ऑब्जेक्ट को "एक्स" होने के लिए होना चाहिए। फिर से, एक उदाहरण के रूप में, प्रकाश को "ACTS LIKE" करने वाली कोई भी चीज में टर्न_ऑन () विधि और टर्न_ऑफ () विधि होनी चाहिए। इंटरफेस का उद्देश्य कंप्यूटर को इन गुणों को लागू करने की अनुमति देना है और यह जानना है कि TYPE T की एक वस्तु (जो भी इंटरफ़ेस है) में एक्स, वाई, जेड, आदि नामक फ़ंक्शन होने चाहिए।

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

Comments

महान व्याख्या; अधिक मान्यता के पात्र हैं।

— अरविंद मणि

Answer 7

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

अधिक जानकारी के लिए

Answer 8

विस्तार : इसका उपयोग मूल वर्ग में मूल वर्ग की विशेषताओं को प्राप्त करने के लिए किया जाता है और इसमें पहले से ही परिभाषित विधियां हो सकती हैं जिन्हें बाल वर्ग में ओवरराइड किया जा सकता है।

इम्प्लीमेंट्स : इसका उपयोग एक इंटरफ़ेस (पेरेंट क्लास फ़ंक्शंस सिग्नेचर के साथ नहीं बल्कि उनकी परिभाषाएँ) को चाइल्ड क्लास में परिभाषित करके किया जाता है।

एक विशेष स्थिति है: "क्या होगा यदि मैं एक नया इंटरफ़ेस चाहता हूं कि वह मौजूदा इंटरफ़ेस का बच्चा हो?"। उपरोक्त स्थिति में, चाइल्ड इंटरफ़ेस माता-पिता के इंटरफ़ेस का विस्तार करता है।

Answer 9

• एक विस्तार बी:

  ए और बी दोनों वर्ग या दोनों इंटरफेस हैं

• एक औजार B

  A एक वर्ग है और B एक इंटरफ़ेस है

• शेष मामला जहां A एक इंटरफ़ेस है और B एक वर्ग है, जावा में कानूनी नहीं है।

Answer 10

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

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

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

कुछ और नोट:

एक इंटरफ़ेस दूसरे इंटरफ़ेस का विस्तार कर सकता है।

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

Answer 11

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

यहाँ असली पकड़ यह है कि जब हम कुछ भी लागू कर रहे हैं तो इसका सीधा मतलब है कि हम उन तरीकों का उपयोग कर रहे हैं जैसा कि यह है। उनके मूल्यों और वापसी के प्रकारों में बदलाव की कोई गुंजाइश नहीं है।

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

Comments

मैं 19 सितंबर को 3 साल से अधिक समय के बाद मेरे द्वारा लिखे गए इस जवाब को पढ़ रहा हूं। मैं कसम खाता हूं कि मैं यह नहीं समझ पा रहा हूं कि मैंने क्या लिखा है। मैं अब और बेहतर उत्तर लिख सकता था। अजीब बात।

— निखिल अरोड़ा

Answer 12

हम का उपयोग उपवर्ग फैली सुपर क्लास केवल जब उपवर्ग कुछ कार्यक्षमता (तरीकों या उदाहरण चर) कि पहले से ही में घोषित किया जाता है का उपयोग करना चाहता सुपर क्लास , या मैं थोड़ा की कार्यक्षमता को संशोधित करना चाहते हैं सुपर क्लास (विधि अधिभावी)। लेकिन कहते हैं, उदाहरण के लिए मेरे पास एक एनिमल क्लास ( सुपरक्लास ) और एक डॉग क्लास ( सबक्लास ) है और ऐसे कुछ तरीके हैं जिन्हें मैंने एनीमल क्लास में परिभाषित किया है। doEat (); , doSleep (); ... और बहुत सारे।

अब, मेरा डॉग क्लास केवल एनिमल क्लास का विस्तार कर सकता है, अगर मैं चाहता हूं कि मेरा कुत्ता एनीमल क्लास में घोषित तरीकों में से किसी का भी इस्तेमाल करे तो मैं उन तरीकों को केवल एक डॉग ऑब्जेक्ट बनाकर इंक्वायरी कर सकता हूं। तो इस तरह से मैं गारंटी दे सकता हूं कि मेरे पास एक कुत्ता है जो खा सकता है और सो सकता है और जो कुछ भी मैं चाहता हूं वह कुत्ता कर सकता है।

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

लेकिन, कहते हैं, कोई पशु वर्ग की एक वस्तु बनाने की कोशिश करता है। आप बता सकते हैं कि एक बिल्ली कैसे सोती है, आप बता सकते हैं कि एक कुत्ता कैसे खाता है, आप बता सकते हैं कि एक हाथी कैसे पीता है। लेकिन पशु वर्ग की वस्तु बनाने में इसका कोई अर्थ नहीं है। क्योंकि यह एक खाका है और हम खाने का कोई सामान्य तरीका नहीं चाहते हैं।

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

तो निष्कर्ष निकालने के लिए, इंटरफ़ेस एक सार वर्ग (एक शुद्ध सार वर्ग) के अलावा कुछ भी नहीं है जिसमें कोई विधि कार्यान्वयन नहीं है, लेकिन केवल परिभाषाएँ (टेम्पलेट) हैं। तो जो कोई भी इंटरफ़ेस लागू करता है, वह जानता है कि उनके पास doEat () के टेम्प्लेट हैं ; और doSleep (); लेकिन उन्हें अपने स्वयं के doEat () को परिभाषित करना होगा ; और doSleep (); उनकी जरूरत के अनुसार तरीके।

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

मैं आपके साथ एक कोड साझा करूंगा: आप इसे इनपुट के विभिन्न सेटों के साथ आज़माएँ और परिणाम देखें।

class AnimalClass {

public void doEat() {

    System.out.println("Animal Eating...");
}

public void sleep() {

    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {

    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();

    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {

    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub

}

@Override
public void herbiEating() {

    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub

}


}

परिभाषित इंटरफेस :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Answer 13

जावा भाषा में अपना नया वर्ग बनाते समय दोनों कीवर्ड का उपयोग किया जाता है।

अंतर: implementsइसका मतलब है कि आप अपनी कक्षा में जावा इंटरफेस के तत्वों का उपयोग कर रहे हैं। extendsइसका मतलब है कि आप जिस आधार वर्ग का विस्तार कर रहे हैं, उसका उपवर्ग बना रहे हैं। आप अपने बच्चे की कक्षा में केवल एक कक्षा का विस्तार कर सकते हैं, लेकिन आप जितने चाहें उतने इंटरफेस लागू कर सकते हैं।

अधिक विवरण के लिए इंटरफ़ेस पर ओरेकल प्रलेखन पृष्ठ देखें।

यह स्पष्ट करने में मदद कर सकता है कि इंटरफ़ेस क्या है, और उनके उपयोग के आसपास के सम्मेलनों।

Answer 14

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

विस्तार :

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

लागू :

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

अगर आपको अभी भी भ्रम है, तो इसे पढ़ें: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI-usinginterface.html

Answer 15

कक्षाएं और इंटरफेस दोनों अनुबंध हैं । वे तरीकों और गुणों को प्रदान करते हैं जो किसी अनुप्रयोग के अन्य भागों पर निर्भर करते हैं।

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

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

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

Answer 16

Extends का उपयोग तब किया जाता है जब आप अपने चाइल्ड क्लास / इंटरफ़ेस में पैरेंट क्लास / इंटरफ़ेस की विशेषताएँ चाहते हैं और implements इसका उपयोग तब किया जाता है जब आप अपनी क्लास में एक इंटरफ़ेस का गुण चाहते हैं।

उदाहरण:

1. कक्षा का उपयोग कर विस्तार करता है

   कक्षा अभिभावक {

   }

   कक्षा में बच्चे का पालन-पोषण

   }

2. इंटरफ़ेस का उपयोग कर विस्तार करता है

   इंटरफ़ेस अभिभावक {

   }

   इंटरफेस चाइल्ड ने माता-पिता को दिया

   }

3. औजार

इंटरफ़ेस ए {

}

कक्षा बी एक ए लागू करता है

}

विस्तार और औजार का संयोजन

interface A{

}

class B

{

}

class C implements A,extends B{

}

Answer 17

फैली

• कक्षा केवल एक कक्षा तक फैली हुई है
• इंटरफ़ेस एक या एक से अधिक इंटरफेस बढ़ाता है

औजार

• कक्षा एक या अधिक इंटरफेस लागू करता है
• इंटरफेस 'कुछ भी लागू नहीं कर सकते हैं

अमूर्त वर्ग भी वर्ग की तरह कार्य करते हैं, विस्तार और लागू होते हैं

Answer 18

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