एक अमूर्त वर्ग एक ऐसा वर्ग है जिसे त्वरित नहीं किया जा सकता है। एक अमूर्त वर्ग का उपयोग एक अंतर्निहित उपवर्ग का निर्माण करके किया जाता है जिसे तत्काल किया जा सकता है। अनुगामी उपवर्ग के लिए एक सार वर्ग कुछ चीजें करता है:
- उन विधियों को परिभाषित करें जिनका उपयोग अंतर्निहित उपवर्ग द्वारा किया जा सकता है।
- अमूर्त तरीकों को परिभाषित करें जो विरासत में उपवर्ग को लागू करना चाहिए।
- एक सामान्य इंटरफ़ेस प्रदान करें जो उपवर्ग को अन्य सभी उपवर्गों के साथ इंटरचेंज करने की अनुमति देता है।
यहाँ एक उदाहरण है:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
ध्यान दें कि "abstractMethod ()" में कोई विधि निकाय नहीं है। इस वजह से, आप निम्न कार्य नहीं कर सकते:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
कोई तरीका नहीं है जो लागू करता है abstractMethod()! इसलिए जेवीएम के लिए यह जानने का कोई तरीका नहीं है कि ऐसा करने के बाद क्या करना चाहिए new ImplementingClass().abstractMethod()।
यहाँ एक सही है ImplementingClass।
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
ध्यान दें कि आपको परिभाषित implementedMethod()या नहीं करना है finalMethod()। वे पहले से ही परिभाषित थे AbstractClass।
यहाँ एक और सही है ImplementingClass।
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
इस मामले में, आपने ओवरराइड किया है implementedMethod()।
हालाँकि, finalकीवर्ड के कारण, निम्नलिखित संभव नहीं है।
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
public void finalMethod() { System.out.print("ERROR!"); }
}
आप की वजह से कार्यान्वयन ऐसा नहीं कर सकते finalMethod()में AbstractClassकी अंतिम कार्यान्वयन के रूप में चिह्नित किया गया है finalMethod()कभी नहीं अन्य कार्यान्वयन की अनुमति दी जाएगी,:।
अब आप एक अमूर्त वर्ग को दो बार भी लागू कर सकते हैं :
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
// In a separate file.
public class SecondImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("second abstractMethod()"); }
}
अब कहीं आप दूसरी विधि लिख सकते थे।
public tryItOut()
{
ImplementingClass a = new ImplementingClass();
AbstractClass b = new ImplementingClass();
a.abstractMethod(); // prints "abstractMethod()"
a.implementedMethod(); // prints "Overridden!" <-- same
a.finalMethod(); // prints "finalMethod()"
b.abstractMethod(); // prints "abstractMethod()"
b.implementedMethod(); // prints "Overridden!" <-- same
b.finalMethod(); // prints "finalMethod()"
SecondImplementingClass c = new SecondImplementingClass();
AbstractClass d = new SecondImplementingClass();
c.abstractMethod(); // prints "second abstractMethod()"
c.implementedMethod(); // prints "implementedMethod()"
c.finalMethod(); // prints "finalMethod()"
d.abstractMethod(); // prints "second abstractMethod()"
d.implementedMethod(); // prints "implementedMethod()"
d.finalMethod(); // prints "finalMethod()"
}
ध्यान दें कि भले ही हमने bएक AbstractClassप्रकार घोषित किया हो , यह प्रदर्शित करता है "Overriden!"। इसका कारण यह है कि जिस वस्तु का हमने तात्पर्य किया था वह वास्तव में एक थी ImplementingClass, जिसकी implementedMethod()निश्चित रूप से अधिकता है। (आपने इसे बहुरूपता के रूप में संदर्भित देखा होगा।)
यदि हम किसी विशेष उपवर्ग के लिए विशिष्ट सदस्य तक पहुँचना चाहते हैं, तो हमें पहले उस उपवर्ग में नीचे उतरना होगा:
// Say ImplementingClass also contains uniqueMethod()
// To access it, we use a cast to tell the runtime which type the object is
AbstractClass b = new ImplementingClass();
((ImplementingClass)b).uniqueMethod();
अंत में, आप निम्न कार्य नहीं कर सकते:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
एक समय में केवल एक वर्ग बढ़ाया जा सकता है। यदि आपको कई वर्गों का विस्तार करने की आवश्यकता है, तो उन्हें इंटरफेस होना चाहिए। तुम यह केर सकते हो:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
यहाँ एक उदाहरण इंटरफ़ेस है:
interface InterfaceA
{
void interfaceMethod();
}
यह मूल रूप से समान है:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
एकमात्र अंतर यह है कि दूसरे तरीके से संकलक को यह पता नहीं चलता है कि यह वास्तव में एक इंटरफ़ेस है। यह उपयोगी हो सकता है यदि आप चाहते हैं कि लोग केवल आपके इंटरफ़ेस को लागू करें और दूसरों को नहीं। हालांकि, अंगूठे के एक सामान्य शुरुआती नियम के रूप में, यदि आपके अमूर्त वर्ग में केवल सार विधियां हैं, तो आपको शायद इसे एक इंटरफ़ेस बनाना चाहिए।
निम्नलिखित अवैध है:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
आप किसी इंटरफ़ेस में विधियों को लागू नहीं कर सकते। इसका मतलब है कि यदि आप दो अलग-अलग इंटरफेस लागू करते हैं, तो उन इंटरफेस में अलग-अलग तरीके टकरा नहीं सकते हैं। चूँकि किसी इंटरफ़ेस में सभी विधियाँ अमूर्त हैं, इसलिए आपको विधि को लागू करना होगा, और चूँकि आपकी विधि वंशानुक्रम में एकमात्र कार्यान्वयन है, इसलिए कंपाइलर जानता है कि उसे आपकी विधि का उपयोग करना है।
