मेन्यू

उदाहरण के साथ जावा इंटरफेस और एब्सट्रैक्ट क्लास ट्यूटोरियल

  • मुख्य
  • अन्य
  • उदाहरण के साथ जावा इंटरफेस और एब्सट्रैक्ट क्लास ट्यूटोरियल

java interface abstract class tutorial with examples

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

यह वीडियो ट्यूटोरियल बताता है कि जावा इंटरफेस क्या है, इसे कैसे लागू किया जाए, और उदाहरणों के साथ जावा में इंटरफेस का उपयोग करते हुए कई विरासत:

हमारे पहले के ट्यूटोरियल में, हमने विस्तार से अमूर्त चर्चा की। वहां हमने अमूर्त वर्गों और अमूर्त विधियों पर चर्चा की। हम जानते हैं कि अमूर्त वर्ग अमूर्तता प्रदान करते हैं क्योंकि हम अमूर्त वर्ग में कुछ गैर-अमूर्त पद्धति भी रख सकते हैं।

जावा में 100% अमूर्तता प्रदान करने वाली विशेषता को 'कहा जाता है' इंटरफेस ”। इस ट्यूटोरियल में हम चर्चा करेंगे जावा में इंटरफेस।

=> यहाँ जावा शुरुआती गाइड पर एक नज़र रखना।

जावा इंटरफेस और एब्स्ट्रैक्ट क्लासेस

आप क्या सीखेंगे:

इंटरफेस और सार कक्षाओं पर वीडियो ट्यूटोरियल

जावा में भाग और सार कक्षाओं का परिचय - भाग 1:

जावा में अंतरक्षेत्रों और सार कक्षाओं का अवलोकन - भाग 2:

जावा में अमूर्तता और विरासत:

जावा में एक इंटरफ़ेस क्या है

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

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

जावा में एक इंटरफ़ेस का एक सरल उदाहरण नीचे दिया गया है।

interface shape{ public static final String color = “Red”; public void calculateArea(); }

उपरोक्त उदाहरण एक इंटरफ़ेस ‘आकार’ को परिभाषित करता है जिसमें एक स्थिर चर और एक सार विधि A गणनाअरी () ’है।

एक इंटरफ़ेस एक इकाई है जिसके शरीर के रूप में केवल सार तरीके हैं। इसमें स्थिर अंतिम चर भी हो सकते हैं।

इसलिए कक्षा की तरह, एक इंटरफ़ेस में भी विधियाँ और चर हो सकते हैं लेकिन ध्यान दें कि विधियाँ अमूर्त (कार्यान्वयन के बिना) और चर स्थिर हैं।

नीचे सूचीबद्ध कुछ गुण हैं जिन्हें इंटरफेसेस से संबंधित ध्यान में रखा जाना चाहिए:

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

इंटरफ़ेस घोषणा का सामान्य सिंटैक्स नीचे दिया गया है।

interface { //constant or static fields declaration //abstract method declaration //default declarations }

जैसा कि उपरोक्त घोषणा में दिखाया गया है, हम एक जावा कीवर्ड “इंटरफ़ेस” का उपयोग करते हैं जो दर्शाता है कि हम अब एक इंटरफ़ेस घोषित कर रहे हैं।

पीसी के लिए सबसे अच्छा मुफ्त विरोधी स्पायवेयर

एक 'इंटरफ़ेस' कीवर्ड के बाद इंटरफ़ेस_नाम और उसके बाद खुलने वाले कर्ल ब्रेसिज़ होते हैं। फिर हमारे पास अमूर्त विधियों, स्थिर क्षेत्रों की घोषणा आदि की विभिन्न घोषणाएँ हैं। अंत में, हम घुंघराले ब्रेसिज़ को बंद कर देते हैं।

उदाहरण के लिए,अगर हम इसमें दो तरीकों के साथ एक इंटरफ़ेस In TestInterface ’घोषित करना चाहते हैं, अर्थात method_one और method_two तो TestInterface की घोषणा निम्नानुसार होगी:

interface TestInterface{ void method_one(); void method_two(); }

जावा में इंटरफ़ेस का उपयोग

  • जावा में इंटरफेस 100% अमूर्तता प्रदान करते हैं क्योंकि उनके पास केवल सार तरीके हो सकते हैं।
  • इंटरफेस का उपयोग करके, हम जावा में कई विरासत प्राप्त कर सकते हैं जो कक्षाओं का उपयोग करना संभव नहीं है।
  • ढीली युग्मन प्राप्त करने के लिए, एक इंटरफ़ेस का उपयोग किया जा सकता है।

जावा में एक इंटरफ़ेस कैसे लागू करें

एक बार इंटरफ़ेस घोषित होने के बाद, हम इसे एक कक्षा में उपयोग कर सकते हैं 'औजार' कीवर्ड का उपयोग करना कक्षा घोषणा में।

नीचे दिखाए गए अनुसार कक्षा के नाम के बाद यह 'लागू होता है' कीवर्ड दिखाई देता है:

class implements { //class body }

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

यदि इंटरफ़ेस को लागू करने वाला वर्ग इंटरफ़ेस में निर्दिष्ट सटीक व्यवहार को लागू नहीं करता है, तो कक्षा को सार के रूप में घोषित करने की आवश्यकता है।

इंटरफ़ेस कार्यान्वयन उदाहरण

नीचे दिए गए जावा में एक इंटरफ़ेस का एक सरल उदाहरण है।

//interface declaration interface Polygon_Shape { void calculateArea(int length, int breadth); } //implement the interface class Rectangle implements Polygon_Shape { //implement the interface method public void calculateArea(int length, int breadth) { System.out.println('The area of the rectangle is ' + (length * breadth)); } } class Main { public static void main(String() args) { Rectangle rect = new Rectangle(); //declare a class object rect.calculateArea(10, 20); //call the method } }

आउटपुट:

आयत उदाहरण उत्पादन का क्षेत्र

उपरोक्त कार्यक्रम जावा में इंटरफेस के सरल उदाहरण को प्रदर्शित करता है। यहाँ, हम Polygon_Shape नाम का एक इंटरफ़ेस घोषित करते हैं और फिर वर्ग आयत इसे लागू करता है।

इंटरफ़ेस नामकरण कन्वेंशन जावा में

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

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

मान्य इंटरफ़ेस नामों के कुछ उदाहरण नीचे दिए गए हैं:

public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}

इंटरफ़ेस निर्माता

अगला सवाल यह है कि क्या एक इंटरफ़ेस में एक कंस्ट्रक्टर है?

हमें पता है कि हमें तरीकों को लागू करने के लिए वस्तुओं की आवश्यकता है। ऑब्जेक्ट बनाने के लिए हमें कंस्ट्रक्टर की आवश्यकता होती है। लेकिन जावा में इंटरफेस के मामले में, तरीकों को लागू नहीं किया जाता है।

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

इंटरफ़ेस के तरीके

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

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

इसलिए यदि शून्य प्रिंटमैथोड () एक प्रोटोटाइप है जिसे हम एक इंटरफ़ेस में घोषित करने का इरादा रखते हैं, तो निम्नलिखित घोषणाएं समान हैं।

void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();

ध्यान दें कि हम इंटरफ़ेस विधियों के लिए इंटरफ़ेस के अंदर निम्नलिखित संशोधक का उपयोग नहीं कर सकते हैं।

  • अंतिम
  • स्थिर
  • निजी
  • संरक्षित
  • सिंक्रनाइज़
  • देशी
  • सख्त

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

//declare an interface interface TestInterface { void printMethod(); //default visibility is public. } //interface implementation class TestClass implements TestInterface { //if the access modifier is changed to any other, compiler generates error public void printMethod() { System.out.println('TestClass::printMethod()'); } } class Main { public static void main(String() args) { TestClass tc = new TestClass(); //create an object tc.printMethod(); //call concrete method } }

आउटपुट:

TestClass PrintMethod

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

मान लें कि हम उपरोक्त कार्यक्रम में इंटरफ़ेस विधि घोषणा को इस प्रकार बदलते हैं:

निजी शून्य प्रिंटमैथोड ();

फिर इसका मतलब है कि हमने इंटरफ़ेस विधि प्रिंटमेथोड () को निजी के रूप में निर्दिष्ट किया है। जब हम प्रोग्राम को संकलित करते हैं, तो हमें निम्नलिखित कंपाइलर त्रुटि मिलती है।

त्रुटि: संशोधक निजी यहाँ अनुमति नहीं है

निजी शून्य प्रिंटमैथोड ();

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

void printMethod() { System.out.println('TestClass::printMethod()'); }

अब यदि हम प्रोग्राम को संकलित करते हैं, तो हमें निम्नलिखित त्रुटि मिलती है।

त्रुटि: PrintMethod () TestClass में PrintMethod () को TestInterface में लागू नहीं किया जा सकता है
शून्य प्रिंटमैथोड ()
^
कमजोर पहुंच विशेषाधिकार प्रदान करने का प्रयास; सार्वजनिक था

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

जावा में इंटरफ़ेस फ़ील्ड

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

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

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

अब इंटरफ़ेस के सभी क्षेत्र डिफ़ॉल्ट स्थैतिक हैं। इसलिए हम इंटरफ़ेस नाम का उपयोग करके उन्हें सीधे उसी तरह एक्सेस कर सकते हैं जैसे हम क्लास के नाम का उपयोग करके क्लास के स्थिर क्षेत्रों तक पहुँचते हैं न कि ऑब्जेक्ट के द्वारा।

नीचे दिए गए उदाहरण जावा प्रोग्राम से पता चलता है कि हम इंटरफ़ेस फ़ील्ड तक कैसे पहुँच सकते हैं।

//interface declaration interface TestInterface{ public static int value = 100; //interface field public void display(); } //Interface implementation class TestClass implements TestInterface{ public static int value = 5000; //class fields public void display() { System.out.println('TestClass::display () method'); } public void show() { System.out.println('TestClass::show () method'); } } public class Main{ public static void main(String args()) { TestClass testObj = new TestClass(); //print interface and class field values. System.out.println('Value of the interface variable (value): '+TestInterface.value); System.out.println('Value of the class variable (value): '+testObj.value); } }

आउटपुट:

इंटरफ़ेस क्षेत्र उदाहरण

जैसा कि ऊपर कार्यक्रम में दिखाया गया है, इंटरफ़ेस फ़ील्ड्स को डॉट ऑपरेटर (और) और फिर वास्तविक चर या फ़ील्ड नाम के बाद इंटरफ़ेस नाम का उपयोग करके एक्सेस किया जा सकता है।

जावा में सामान्य इंटरफ़ेस

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

जेनेरिक इंटरफेस को प्रकार के मापदंडों के साथ घोषित किया जाता है जो उन्हें डेटा प्रकार से स्वतंत्र बनाता है।

सामान्य इंटरफ़ेस का सामान्य सिंटैक्स निम्नानुसार है:

विंडोज़ के लिए मुफ्त फ़ायरवॉल डाउनलोड 10
interface { //interface methods and variables }

अब यदि हम एक वर्ग में उपरोक्त सामान्य इंटरफ़ेस का उपयोग करना चाहते हैं, तो हम कर सकते हैं वर्ग परिभाषा नीचे दिखाए अनुसार:

class implements interface_name { //class body }

ध्यान दें कि हमें इंटरफ़ेस के साथ कक्षा के साथ समान पैराम-सूची को निर्दिष्ट करना होगा।

निम्न जावा प्रोग्राम जावा में जेनेरिक इंटरफेस को प्रदर्शित करता है।

//generic interface declaration interface MinInterface>{ T minValue(); } //implementation for generic interface class MinClassImpl> implements MinInterface { T() intArray; MinClassImpl(T() o) { intArray = o; } public T minValue() { T v = intArray(0); for (int i = 1; i intMinValue = new MinClassImpl (intArray); MinClassImpl charMinValue = new MinClassImpl(charArray); //call interface method minValue for int type array System.out.println('Min value in intOfArray: ' + intMinValue.minValue()); //call interface method minValue for char type array System.out.println('Min value in charOfArray: ' + charMinValue.minValue()); }

आउटपुट:

सामान्य इंटरफ़ेस उदाहरण आउटपुट

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

जावा में कई इंटरफेस

हमारे उत्तराधिकार विषय में, हमने देखा है कि जावा एक वर्ग को कई वर्गों से विरासत में प्राप्त करने की अनुमति नहीं देता है क्योंकि इससे 'डायमंड प्रॉब्लम' नामक अस्पष्टता उत्पन्न होती है।

हालाँकि, एक वर्ग एक से अधिक इंटरफ़ेस को इनहेरिट या कार्यान्वित कर सकता है। इस मामले में, इसे कई उत्तराधिकार के रूप में जाना जाता है। इसलिए यद्यपि हमें कक्षाओं के माध्यम से जावा में कई विरासत को लागू करने की अनुमति नहीं है, हम इंटरफेस का उपयोग करके ऐसा कर सकते हैं।

निम्नलिखित आरेख इंटरफेस का उपयोग करते हुए कई विरासत को दर्शाता है। यहां एक वर्ग दो इंटरफेस यानी इंटरफेस_ऑन और इंटरफेस_ट्वो को लागू करता है।

जावा में कई इंटरफेस

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

जावा प्रोग्राम जो कई इंटरफेस प्रदर्शित करता है, नीचे दिखाया गया है।

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration interface Interface_Two{ void show(); } //multiple inheritance - DemoClass implementing Interface_One&Interface_Two class DemoClass implements Interface_One,Interface_Two{ public void print(){ //Override Interface_One print() System.out.println('Democlass::Interface_One_Print ()'); } public void show(){ //Override Interface_Two show() System.out.println('DemoClass::Interface_Two_Show ()'); } } public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

आउटपुट:

कई इंटरफेस उदाहरण

iPhone के लिए सबसे अच्छा परियोजना प्रबंधन अनुप्रयोग

जैसा कि ऊपर दिखाया गया है, हम दो इंटरफेस लागू करते हैं। फिर हम उनके संबंधित तरीकों को ओवरराइड करते हैं और उन्हें मुख्य विधि में बुलाते हैं।

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

इंटरफ़ेस इनहेरिटेंस इन जावा: इंटरफ़ेस का विस्तार इंटरफ़ेस है

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

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

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

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration; inherits from Interface_One interface Interface_Two extends Interface_One{ void show(); } //multiple inheritance - DemoClass implementing Interface_Two class DemoClass implements Interface_Two{ public void print(){ //Override Interface_Two print() System.out.println('Democlass public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

आउटपुट:

डेमो क्लास उदाहरण आउटपुट

हमने उसी प्रोग्राम को संशोधित किया है, जिसका उपयोग हमने इंटरफेस इनहेरिटेंस को प्रदर्शित करने के लिए इंटरफेस का उपयोग करते हुए कई विरासत के लिए किया था। यहां, हम Interface_two को Interface_two में विस्तारित करते हैं और फिर एक वर्ग में Interface_two को लागू करने के बारे में जाते हैं। जैसा कि इंटरफेस विरासत में मिला है, दोनों तरीके ओवरराइडिंग के लिए उपलब्ध हैं।

बार बार पूछे जाने वाले प्रश्न

Q # 1) जावा में इंटरफ़ेस का उपयोग क्या है?

उत्तर: जावा में एक इंटरफ़ेस एक इकाई है जिसका उपयोग 100% अमूर्तता प्राप्त करने के लिए किया जाता है। इसमें केवल अमूर्त विधियाँ हो सकती हैं जिन्हें इंटरफ़ेस को लागू करने वाले वर्ग द्वारा ओवरराइड किया जा सकता है।

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

Q # 2) जावा में इंटरफ़ेस के क्या फायदे हैं?

उत्तर: इंटरफ़ेस के कुछ लाभ इस प्रकार हैं:

  1. इंटरफ़ेस क्लास के ब्लूप्रिंट के रूप में कार्य करता है।
  2. इंटरफ़ेस जावा में 100% अमूर्तता प्रदान करता है क्योंकि इसमें सभी सार तरीके हैं।
  3. जावा में कई विरासत प्राप्त करने के लिए इंटरफेस का उपयोग किया जा सकता है। जावा एक से अधिक वर्ग से विरासत की अनुमति नहीं देता है लेकिन एक वर्ग कई इंटरफेस को लागू कर सकता है।

# 3) क्या एक इंटरफ़ेस के तरीके हो सकते हैं?

उत्तर: इंटरफेस में विधियों और स्थिर और अंतिम स्थिरांक के प्रोटोटाइप हो सकते हैं। लेकिन जावा 8 से शुरू, इंटरफेस में स्थिर और डिफ़ॉल्ट तरीके हो सकते हैं।

Q # 4) क्या हम इंटरफ़ेस को अंतिम घोषित कर सकते हैं?

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

इंटरफेस के बारे में अधिक

इंटरफेस क्लास की तरह ब्लूप्रिंट होते हैं, लेकिन इसमें केवल विधि की घोषणा होगी। इसे लागू करने का कोई तरीका नहीं है। इंटरफ़ेस में सभी विधियां डिफ़ॉल्ट रूप से सार्वजनिक सार हैं। जावा 1.8 इंटरफ़ेस में स्थिर और डिफ़ॉल्ट विधियाँ हो सकती हैं।

इंटरफ़ेस में मुख्य रूप से इंटरफेस का उपयोग किया जाता है।

उदाहरण के लिए: विचार करें कि आप वाहन का इंजन डिजाइन कर रहे हैं।

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

Interface Engine { void changeGear(int a); void speedUp(int a); }

इंटरफ़ेस के लिए नियमों का पालन किया जाना चाहिए

  • इंटरफ़ेस को लागू करने वाला वर्ग इंटरफ़ेस के सभी तरीकों को लागू करना चाहिए।
  • एक इंटरफ़ेस में अंतिम चर हो सकते हैं।
public class Vehicle implements Engine { int speed; int gear; @Override public void speedUp(int a) { this.speed=a; System.out.println('speed'+speed); } @Override public void changeGear(int a) { this.gear=a; System.out.println('gear'+gear); } public static void main(String() args) { // TODO Auto-generated method stub Vehicle objv=new Vehicle(); objv.changeGear(3); objv.speedUp(70); } }

इंटरफ़ेस के लिए नियमों का पालन किया जाना चाहिए

यहां वाहन वर्ग उपवर्ग है जो इंजन इंटरफ़ेस को लागू कर रहा है।

अमूर्त वर्ग क्या हैं?

एक अमूर्त वर्ग एक वर्ग की तरह है लेकिन इसमें अमूर्त विधियाँ और ठोस विधियाँ होंगी। सार विधियों का कार्यान्वयन नहीं होता है। इसमें केवल विधि घोषणा होगी।

सार वर्ग के लिए नियमों का पालन किया जाना चाहिए

  • अमूर्त वर्ग को तत्काल नहीं किया जा सकता है।
  • बाल वर्ग जो अमूर्त वर्ग का विस्तार करता है, उसे मूल वर्ग के सभी अमूर्त तरीकों को लागू करना चाहिए या बाल वर्ग को एक सार वर्ग के रूप में घोषित किया जाना चाहिए।

जब आप आंशिक कार्यान्वयन डिजाइन करना चाहते हैं, तो आप एक सार वर्ग के लिए जा सकते हैं।

उदाहरण सार वर्ग कार्यक्रम:

EmployeeDetails.java

public abstract class EmployeeDetails { private String name; private int emp_ID; public void commonEmpDetaills() { System.out.println('Name'+name); System.out.println('emp_ID'+emp_ID); } public abstract void confidentialDetails(int s,String p); }

कर्मचारी

वह वर्ग जो अमूर्त वर्ग का विस्तार करने वाला है।

HR.java

public class HR extends EmployeeDetails { private int salary; private String performance; @Override public void confidentialDetails(int s,String p) { this.salary=s; this.performance=p; System.out.println('salary=='+salary); System.out.println('performance=='+performance); } public static void main(String() args) { HR hr =new HR(); hr.confidentialDetails(5000,'good'); } }

घंटा-जावा

ध्यान देने योग्य मुख्य बातें:

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

निष्कर्ष

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

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

=> सभी के लिए जावा प्रशिक्षण श्रृंखला देखने के लिए यहां जाएं

अनुशंसित पाठ

^