एक ही विधि के नाम और हस्ताक्षर के साथ दो इंटरफेस। लेकिन एक ही वर्ग द्वारा कार्यान्वित किया जाता है फिर कंपाइलर किस विधि की पहचान करेगा कि किस इंटरफ़ेस के लिए है?
उदाहरण के लिए:
interface A{
int f();
}
interface B{
int f();
}
class Test implements A, B{
public static void main(String... args) throws Exception{
}
@Override
public int f() { // from which interface A or B
return 0;
}
}
जवाबों:
यदि एक प्रकार दो इंटरफेस को लागू करता है, और प्रत्येक interfaceएक ऐसी विधि को परिभाषित करता है जिसमें समान हस्ताक्षर होते हैं, तो वास्तव में एक ही विधि है, और वे अलग-अलग नहीं हैं। यदि कहें, दो तरीकों में परस्पर विरोधी रिटर्न प्रकार हैं, तो यह एक संकलन त्रुटि होगी। यह वंशानुक्रम, विधि के ओवरराइड करने, छिपाने और घोषणाओं का सामान्य नियम है, और यह केवल 2 विरासत वाले interfaceतरीकों के बीच संभावित संघर्षों पर भी लागू होता है , लेकिन यह भी एक interfaceऔर एक सुपर classविधि, या यहां तक कि जेनेरिक के प्रकार के कारण संघर्ष भी है।
यहां एक उदाहरण है जहां आपके पास एक है interface Gift, जिसमें एक present()विधि है (जैसे, उपहार पेश करना), और एक भी interface Guest, जिसमें एक present()विधि भी है (जैसा कि, अतिथि मौजूद है और अनुपस्थित नहीं है)।
Presentable johnnya Giftऔर a दोनों है Guest।
public class InterfaceTest {
interface Gift { void present(); }
interface Guest { void present(); }
interface Presentable extends Gift, Guest { }
public static void main(String[] args) {
Presentable johnny = new Presentable() {
@Override public void present() {
System.out.println("Heeeereee's Johnny!!!");
}
};
johnny.present(); // "Heeeereee's Johnny!!!"
((Gift) johnny).present(); // "Heeeereee's Johnny!!!"
((Guest) johnny).present(); // "Heeeereee's Johnny!!!"
Gift johnnyAsGift = (Gift) johnny;
johnnyAsGift.present(); // "Heeeereee's Johnny!!!"
Guest johnnyAsGuest = (Guest) johnny;
johnnyAsGuest.present(); // "Heeeereee's Johnny!!!"
}
}
उपरोक्त स्निपेट संकलन और चलाता है।
ध्यान दें कि केवल एक ही @Override आवश्यक है !!! । इसका कारण यह है Gift.present()और Guest.present()" @Overrideअसमान" ( JLS 8.4.2 ) हैं।
इस प्रकार, johnny केवल एक ही कार्यान्वयन है present(), और इससे कोई फर्क नहीं पड़ता कि आप कैसे व्यवहार करते हैं johnny, चाहे एक Giftया एक के रूप में Guest, एक ही तरीका है।
यहाँ एक उदाहरण है जहाँ दो विरासत में मिली विधियाँ @Overrideअसमान नहीं हैं :
public class InterfaceTest {
interface Gift { void present(); }
interface Guest { boolean present(); }
interface Presentable extends Gift, Guest { } // DOES NOT COMPILE!!!
// "types InterfaceTest.Guest and InterfaceTest.Gift are incompatible;
// both define present(), but with unrelated return types"
}
यह आगे दोहराता है कि सदस्यों को विरासत में प्राप्त होने interfaceवाले सदस्य घोषणाओं के सामान्य नियम का पालन करना चाहिए। यहां हमारे पास असंगत रिटर्न प्रकारों के साथ हैं Giftऔर Guestपरिभाषित present()करते हैं: एक voidदूसरे के साथ boolean। उसी कारण से कि आप एक void present()और boolean present()एक प्रकार में नहीं कर सकते हैं , इस उदाहरण के परिणामस्वरूप संकलन त्रुटि होती है।
आप उन तरीकों को विरासत में दे सकते हैं @Override, जो असमान हैं, विधि की सामान्य आवश्यकताओं के अधीन होते हैं जो ओवरराइडिंग और छुपाते हैं। क्योंकि वे हैं @Override -equivalent, प्रभावी रूप से वहाँ लागू करने के लिए केवल एक ही तरीका है, और इस तरह वहाँ भेद / से चयन करने के लिए कुछ भी नहीं है।
कंपाइलर को यह पता लगाने की आवश्यकता नहीं है कि कौन सी विधि किस इंटरफ़ेस के लिए है, क्योंकि एक बार जब वे निर्धारित होने के लिए @Override-सामान्य होते हैं, तो वे एक ही विधि होते हैं।
संभावित असंगतताओं को हल करना एक मुश्किल काम हो सकता है, लेकिन यह पूरी तरह से एक और मुद्दा है।
defaultजावा 8 में विधियों के समर्थन से थोड़ा बदल जाता है
Fooऔर Bar। मूल रूप से आपके पास अपनी कक्षा को इंटरफेस में से एक को लागू करने, कहने Fooऔर Bar asBar()आंतरिक Barइंटरफ़ेस को वापस करने के लिए एक विधि प्रदान करता है जो दूसरे इंटरफ़ेस को लागू करता है। सही नहीं है क्योंकि आपकी कक्षा अंततः "एक बार" नहीं है, लेकिन यह कुछ परिस्थितियों में उपयोगी हो सकता है।
इसे इस प्रश्न के डुप्लिकेट के रूप में चिह्नित किया गया था /programming/24401064/understanding-and-solve-the-diamond-problems-in-java
आपको एक बहु विरासत समस्या प्राप्त करने के लिए जावा 8 की आवश्यकता है, लेकिन यह अभी भी इस तरह से एक diamon समस्या नहीं है।
interface A {
default void hi() { System.out.println("A"); }
}
interface B {
default void hi() { System.out.println("B"); }
}
class AB implements A, B { // won't compile
}
new AB().hi(); // won't compile.
जेबी निज़ेट की टिप्पणियों के रूप में आप इसे मेरे ओवरराइडिंग को ठीक कर सकते हैं।
class AB implements A, B {
public void hi() { A.super.hi(); }
}
हालाँकि, आपको इससे कोई समस्या नहीं है
interface D extends A { }
interface E extends A { }
interface F extends A {
default void hi() { System.out.println("F"); }
}
class DE implement D, E { }
new DE().hi(); // prints A
class DEF implement D, E, F { }
new DEF().hi(); // prints F as it is closer in the heirarchy than A.
hi()(अस्पष्टता को ठीक करने के लिए) करना है। उदाहरण के लिए, इसे लागू A.super.hi()करने के लिए इसे उसी तरह लागू करने के लिए चुनें जैसे कि ए
जहां तक संकलक का संबंध है, वे दो विधियां समान हैं। दोनों का एक कार्यान्वयन होगा।
यह एक समस्या नहीं है यदि दो विधियां प्रभावी रूप से समान हैं, तो इसमें उनका कार्यान्वयन समान होना चाहिए। यदि वे संविदात्मक रूप से भिन्न हैं (प्रत्येक इंटरफ़ेस के लिए प्रलेखन के अनुसार), तो आप मुश्किल में पड़ जाएंगे।
पहचान के लिए कुछ भी नहीं है। इंटरफेस केवल एक विधि का नाम और हस्ताक्षर के साथ मुकदमा चलाते हैं। यदि दोनों इंटरफेस में एक ही नाम और हस्ताक्षर की एक विधि है, तो कार्यान्वयन वर्ग एक ही ठोस विधि के साथ दोनों इंटरफ़ेस विधियों को लागू कर सकता है।
हालाँकि, यदि दो इंटरफ़ेस विधि के शब्दार्थ अनुबंध विपरीत हैं, तो आप बहुत अधिक खो चुके हैं; आप तब एक ही वर्ग में दोनों इंटरफेस को लागू नहीं कर सकते।
अनाम के रूप में इंटरफ़ेस को लागू करने का प्रयास करें।
public class MyClass extends MySuperClass implements MyInterface{
MyInterface myInterface = new MyInterface(){
/* Overrided method from interface */
@override
public void method1(){
}
};
/* Overrided method from superclass*/
@override
public void method1(){
}
}
जैसा कि इंटरफ़ेस में, हम केवल तरीकों की घोषणा कर रहे हैं, ठोस वर्ग जो इन दोनों इंटरफेसों को लागू करता है वह समझता है कि केवल एक ही विधि है (जैसा कि आपने वर्णित है कि रिटर्न प्रकार में दोनों का एक ही नाम है)। इसलिए इसके साथ कोई समस्या नहीं होनी चाहिए। आप उस विधि को ठोस वर्ग में परिभाषित कर पाएंगे।
लेकिन जब दो इंटरफ़ेस में एक ही नाम के साथ एक विधि होती है, लेकिन अलग-अलग रिटर्न टाइप होते हैं और आप दो तरीकों को कंक्रीट क्लास में लागू करते हैं:
कृपया नीचे दिए गए कोड को देखें:
public interface InterfaceA {
public void print();
}
public interface InterfaceB {
public int print();
}
public class ClassAB implements InterfaceA, InterfaceB {
public void print()
{
System.out.println("Inside InterfaceA");
}
public int print()
{
System.out.println("Inside InterfaceB");
return 5;
}
}
जब कंपाइलर को "public void print ()" मेथड दिखाई देता है, तो यह पहली बार InterfaceA में दिखता है और यह इसे प्राप्त करता है। लेकिन अभी भी यह संकलन समय त्रुटि देता है कि वापसी प्रकार InterfaceB के तरीके के साथ संगत नहीं है।
तो यह संकलक के लिए haywire जाता है।
इस तरह, आप दो इंटरफ़ेस को लागू नहीं कर पाएंगे, जिसमें एक ही नाम की एक विधि होगी, लेकिन अलग-अलग रिटर्न प्रकार।
अगर वे दोनों एक ही हैं तो इससे कोई फर्क नहीं पड़ता। यह प्रति इंटरफ़ेस विधि के साथ एक ठोस विधि के साथ दोनों को लागू करता है।