यदि मेरे पास दो इंटरफेस हैं, तो दोनों अपने उद्देश्यों में काफी भिन्न हैं, लेकिन एक ही विधि हस्ताक्षर के साथ, मैं कैसे एक वर्ग को लागू करने के लिए मजबूर कर सकता हूं बिना एक भी विधि लिखने के लिए जो दोनों इंटरफेस के लिए कार्य करता है और विधि में कुछ जटिल तर्क लिखता है कार्यान्वयन जो जाँचता है कि किस प्रकार की वस्तु को कॉल किया जा रहा है और उचित कोड का आह्वान करें?
C # में, इसे स्पष्ट इंटरफ़ेस कार्यान्वयन के रूप में कहा जाता है। क्या जावा में कोई समान तरीका है?
जवाबों:
नहीं, जावा में एक कक्षा में दो अलग-अलग तरीकों से एक ही तरीके को लागू करने का कोई तरीका नहीं है।
यह कई भ्रामक स्थितियों को जन्म दे सकता है, यही वजह है कि जावा ने इसे अस्वीकार कर दिया है।
interface ISomething {
void doSomething();
}
interface ISomething2 {
void doSomething();
}
class Impl implements ISomething, ISomething2 {
void doSomething() {} // There can only be one implementation of this method.
}
आप क्या कर सकते हैं दो वर्गों में से एक वर्ग की रचना करें जो प्रत्येक एक अलग इंटरफ़ेस को लागू करता है। तब उस एक वर्ग में दोनों इंटरफेस का व्यवहार होगा।
class CompositeClass {
ISomething class1;
ISomething2 class2;
void doSomething1(){class1.doSomething();}
void doSomething2(){class2.doSomething();}
}
ISomething1 CompositeClass.asInterface1();और ISomething2 CompositeClass.asInterface2();तरीका जोड़ दें । तब आप केवल एक या दूसरे को समग्र वर्ग से बाहर निकाल सकते हैं। हालांकि इस समस्या का कोई बड़ा हल नहीं है।
public long getCountAsLong() implements interface2.getCount {...}[मामले में इंटरफ़ेस की आवश्यकता होती है, longलेकिन वर्ग के उपयोगकर्ताओं को अपेक्षा होती है int] या private void AddStub(T newObj) implements coolectionInterface.Add[ collectionInterfaceएक canAdd()विधि है, और इस वर्ग के सभी उदाहरणों के लिए यह वापस आ जाता है false]?
जावा में इसे हल करने का कोई वास्तविक तरीका नहीं है। आप आंतरिक कक्षाओं को वर्कअराउंड के रूप में उपयोग कर सकते हैं:
interface Alfa { void m(); }
interface Beta { void m(); }
class AlfaBeta implements Alfa {
private int value;
public void m() { ++value; } // Alfa.m()
public Beta asBeta() {
return new Beta(){
public void m() { --value; } // Beta.m()
};
}
}
यद्यपि यह जातियों के लिए अनुमति नहीं देता AlfaBetaहै Beta, लेकिन डाउनकास्ट आम तौर पर बुराई है, और अगर यह उम्मीद की जा सकती है कि एक Alfaउदाहरण में अक्सर एक Betaपहलू भी होता है, और किसी कारण से (आमतौर पर अनुकूलन एकमात्र वैध कारण होता है) आप सक्षम होना चाहते हैं यह परिवर्तित करने के लिए करने के लिए Beta, आप की एक उप-इंटरफ़ेस बना सकता है Alfaके साथ Beta asBeta()उस में।
यदि आप इस समस्या का सामना कर रहे हैं, तो यह सबसे अधिक संभावना है क्योंकि आप विरासत का उपयोग कर रहे हैं जहां आपको प्रतिनिधिमंडल का उपयोग करना चाहिए । यदि आपको दो अलग-अलग प्रदान करने की आवश्यकता है, तो समान है, डेटा के समान अंतर्निहित मॉडल के लिए इंटरफेस है, तो आपको कुछ अन्य इंटरफ़ेस का उपयोग करके सस्ते में डेटा तक पहुंच प्रदान करने के लिए एक दृश्य का उपयोग करना चाहिए ।
उत्तरार्द्ध मामले के लिए एक ठोस उदाहरण देने के लिए, मान लीजिए कि आप दोनों को लागू करना चाहते हैं Collectionऔर MyCollection(जिसमें Collectionकोई अंतर नहीं है और एक असंगत इंटरफ़ेस है)। आप एक Collection getCollectionView()और MyCollection getMyCollectionView()कार्य प्रदान कर सकते हैं जो एक ही अंतर्निहित डेटा का उपयोग करते हुए, एक हल्के वजन का कार्यान्वयन प्रदान करते हैं Collectionऔर MyCollection।
पूर्व मामले के लिए ... मान लीजिए कि आप वास्तव में पूर्णांकों की एक श्रृंखला और तार की एक सरणी चाहते हैं। दोनों से इनहेरिट करने के बजाय List<Integer>और List<String>, आप प्रकार के एक सदस्य होना चाहिए List<Integer>और प्रकार के एक अन्य सदस्य List<String>हैं, और उन सदस्यों के लिए दोनों से प्राप्त करना नहीं बल्कि कोशिश की तुलना में, देखें। यहां तक कि अगर आपको केवल पूर्णांक की एक सूची की आवश्यकता है, तो इस मामले में विरासत पर रचना / प्रतिनिधिमंडल का उपयोग करना बेहतर है।
"शास्त्रीय" जावा समस्या मेरे Android विकास को भी प्रभावित करती है ...
इसका कारण सरल प्रतीत होता है:
आपके द्वारा उपयोग की जाने वाली अधिक चौखटें / पुस्तकालय, अधिक आसानी से चीजें नियंत्रण से बाहर हो सकती हैं ...
मेरे मामले में, मेरे पास एक BootStrapperApp वर्ग है android.app.Application से विरासत में मिला है ,
जबकि एक ही वर्ग को एकीकृत करने के लिए MVVM फ्रेमवर्क के प्लेटफ़ॉर्म इंटरफ़ेस को भी लागू करना चाहिए ।
विधि टकराव एक गेटस्ट्रिंग () विधि पर हुआ , जो दोनों इंटरफेस द्वारा घोषित किया गया है और अलग-अलग संदर्भों में अलग-अलग कार्यान्वयन होना चाहिए।
वर्कअराउंड (बदसूरत..आईएमओ) सभी प्लेटफॉर्म को लागू करने के लिए एक आंतरिक वर्ग का उपयोग कर रहा हैतरीकों, सिर्फ एक मामूली विधि हस्ताक्षर संघर्ष के कारण ... कुछ मामलों में, ऐसी उधार विधि का उपयोग बिल्कुल भी नहीं किया जाता है (लेकिन प्रभावित प्रमुख डिजाइन शब्दार्थ)।
मैं सहमत हूँ कि C # -स्टाइल स्पष्ट संदर्भ / नाम स्थान संकेत उपयोगी है।
मेरे दिमाग में आया एकमात्र समाधान रेफरी वस्तुओं का उपयोग कर रहा है, जिसे आप मुलर चेतावनियों को निहित करना चाहते हैं।
उदाहरण: आप को लागू करने के लिए 2 इंटरफेस हैं
public interface Framework1Interface {
void method(Object o);
}
तथा
public interface Framework2Interface {
void method(Object o);
}
आप उन्हें दो मुख् य वस्तुओं में संलग्न कर सकते हैं:
public class Facador1 implements Framework1Interface {
private final ObjectToUse reference;
public static Framework1Interface Create(ObjectToUse ref) {
return new Facador1(ref);
}
private Facador1(ObjectToUse refObject) {
this.reference = refObject;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Framework1Interface) {
return this == obj;
} else if (obj instanceof ObjectToUse) {
return reference == obj;
}
return super.equals(obj);
}
@Override
public void method(Object o) {
reference.methodForFrameWork1(o);
}
}
तथा
public class Facador2 implements Framework2Interface {
private final ObjectToUse reference;
public static Framework2Interface Create(ObjectToUse ref) {
return new Facador2(ref);
}
private Facador2(ObjectToUse refObject) {
this.reference = refObject;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Framework2Interface) {
return this == obj;
} else if (obj instanceof ObjectToUse) {
return reference == obj;
}
return super.equals(obj);
}
@Override
public void method(Object o) {
reference.methodForFrameWork2(o);
}
}
अंत में आपको जो वर्ग चाहिए वह कुछ ऐसा होना चाहिए
public class ObjectToUse {
private Framework1Interface facFramework1Interface;
private Framework2Interface facFramework2Interface;
public ObjectToUse() {
}
public Framework1Interface getAsFramework1Interface() {
if (facFramework1Interface == null) {
facFramework1Interface = Facador1.Create(this);
}
return facFramework1Interface;
}
public Framework2Interface getAsFramework2Interface() {
if (facFramework2Interface == null) {
facFramework2Interface = Facador2.Create(this);
}
return facFramework2Interface;
}
public void methodForFrameWork1(Object o) {
}
public void methodForFrameWork2(Object o) {
}
}
अब आप अपनी कक्षा को "बेनकाब" करने के लिए गेट्स * के तरीकों का उपयोग कर सकते हैं
सभी अच्छी तरह से और अच्छा जब आपके पास प्रश्न में सभी कोड पर कुल नियंत्रण होता है और इस अपफ्रंट को लागू कर सकता है। अब कल्पना करें कि आपके पास एक मौजूदा सार्वजनिक वर्ग है जिसका उपयोग कई स्थानों पर विधि के साथ किया जाता है
public class MyClass{
private String name;
MyClass(String name){
this.name = name;
}
public String getName(){
return name;
}
}
अब आपको इसे शेल्फ में पास करने की आवश्यकता है WizzBangProcessor जिसे WBPInterface को लागू करने के लिए कक्षाओं की आवश्यकता होती है ... जिसमें गेटनेम () विधि भी है, लेकिन आपके ठोस कार्यान्वयन के बजाय, यह इंटरफ़ेस एक प्रकार का नाम वापस करने की विधि की अपेक्षा करता है। Wizz बैंग प्रसंस्करण की।
C # में यह एक ट्रिवियल होगा
public class MyClass : WBPInterface{
private String name;
String WBPInterface.getName(){
return "MyWizzBangProcessor";
}
MyClass(String name){
this.name = name;
}
public String getName(){
return name;
}
}
जावा टफ में आपको मौजूदा तैनात कोड बेस में हर बिंदु की पहचान करनी होगी, जहां आपको एक इंटरफेस से दूसरे में बदलने की जरूरत है। यकीन है कि WizzBangProcessor कंपनी को getWizzBangProcessName () का उपयोग करना चाहिए था, लेकिन वे डेवलपर्स भी हैं। उनके संदर्भ में getName ठीक था। दरअसल, जावा के बाहर, अधिकांश अन्य OO आधारित भाषाएं इसका समर्थन करती हैं। जावा सभी तरीकों को एक ही विधि NAME के साथ लागू करने के लिए मजबूर करने में दुर्लभ है।
अधिकांश अन्य भाषाओं में एक कंपाइलर होता है जो "इस वर्ग में इस पद्धति जो इस कार्यान्वित इंटरफ़ेस में इस पद्धति के हस्ताक्षर से मेल खाता है, इसे लागू करना है" कहने के लिए एक निर्देश लेने से अधिक खुशी है। अंतरापृष्ठों को परिभाषित करने के पूरे बिंदु के बाद परिभाषा को क्रियान्वयन से अलग करने की अनुमति है। (जावा में इंटरफेस में डिफ़ॉल्ट तरीके होने पर भी मुझे शुरू न करें, अकेले डिफ़ॉल्ट को ओवरराइड करने दें ... क्योंकि निश्चित रूप से, सड़क कार के लिए डिज़ाइन किए गए प्रत्येक घटक को उड़ान कार में पटक दिया जाना चाहिए और बस काम करना चाहिए - हे वे दोनों कार हैं ... मुझे यकीन है कि डिफ़ॉल्ट कार्यक्षमता का कहना है कि आपकी संतृप्त नौसेना डिफ़ॉल्ट पिच और रोल इनपुट से प्रभावित नहीं होगी, क्योंकि कारें केवल जम्हाई लेती हैं!