marker interface java
यह ट्यूटोरियल बताता है कि जावा में मार्कर इंटरफ़ेस क्या है। यह कोड के उदाहरणों के साथ जावा में सीरियल डिजिटलाइज़ेशन और क्लोनिंग को भी शामिल करता है:
हम इंटरफेस के तहत अंतिम विषय पर चर्चा करेंगे, अर्थात जावा में मार्कर इंटरफ़ेस।
मार्कर इंटरफेस के साथ काम करने के बाद हम दो उदाहरणों पर चर्चा करेंगे अर्थात् जावा में क्रमबद्ध और क्लोन करने योग्य इंटरफ़ेस। मार्कर इंटरफेस के साथ शुरू करते हैं।
=> स्क्रैच से जावा सीखने के लिए यहां जाएं
आप क्या सीखेंगे:
- जावा में मार्कर इंटरफ़ेस
- जावा में क्रमांकन
- जावा सीरियल इंटरफ़ेस
- जावा में क्लोन करने योग्य इंटरफ़ेस
- निष्कर्ष
जावा में मार्कर इंटरफ़ेस
जावा में एक मार्कर इंटरफ़ेस एक खाली इंटरफ़ेस है जिसमें कोई फ़ील्ड या विधियाँ नहीं हैं। यह मार्कर इंटरफ़ेस कंपाइलर को बताता है कि मार्कर इंटरफ़ेस को लागू करने वाले वर्ग के ऑब्जेक्ट अलग-अलग हैं और उन्हें अलग तरह से व्यवहार किया जाना चाहिए।
जावा में प्रत्येक मार्कर इंटरफ़ेस इंगित करता है कि यह JVM या संकलक के लिए कुछ विशेष का प्रतिनिधित्व करता है।
जावा में, हमारे पास तीन इंटरफेस हैं जो नीचे दिखाए अनुसार मार्कर इंटरफेस हैं:
(1) सीरियल इंटरफ़ेस: Serializable java.io पैकेज में मौजूद एक मार्कर इंटरफ़ेस है। हम इस इंटरफ़ेस का उपयोग करके ऑब्जेक्ट्स को अनुक्रमित कर सकते हैं यानी किसी फ़ाइल में ऑब्जेक्ट स्थिति को बचा सकते हैं।
# 2) क्लोन करने योग्य इंटरफ़ेस: क्लोन करने योग्य इंटरफ़ेस java.lang पैकेज का एक हिस्सा है और वस्तुओं को क्लोन करने की अनुमति देता है।
# 3) रिमोट इंटरफ़ेस: रिमोट इंटरफ़ेस java.RMI पैकेज का एक हिस्सा है और हम RMI एप्लिकेशन बनाने के लिए इस इंटरफ़ेस का उपयोग करते हैं। यह इंटरफ़ेस मुख्य रूप से दूरस्थ वस्तुओं से संबंधित है।
इस ट्यूटोरियल में, हम क्रमबद्ध और क्लोन करने योग्य इंटरफ़ेस पर चर्चा करेंगे। जब हम जावा में RMI में जाते हैं, तो दूरस्थ इंटरफ़ेस पर चर्चा की जाएगी।
जावा में क्रमांकन
इससे पहले कि हम जावा में अनुक्रमिक इंटरफ़ेस के विवरण में जाएं, आइए क्रमबद्धता की प्रक्रिया के साथ-साथ जावा में डीरियलाइज़ेशन की प्रक्रिया को भी समझें।
सीरियलाइज़ेशन को एक ऐसी प्रक्रिया के रूप में परिभाषित किया जा सकता है, जिसके द्वारा हम ऑब्जेक्ट को फाइल या मेमोरी में ऑब्जेक्ट को स्टोर करने के लिए उसकी समकक्ष बाइट स्ट्रीम में परिवर्तित करते हैं। दृढ़ रहना वस्तु।
जब हम ऑब्जेक्ट को उसके सहेजे गए राज्य से प्राप्त करना चाहते हैं और उसकी सामग्री तक पहुँच प्राप्त करना चाहते हैं, तो हमें बाइट स्ट्रीम को वास्तविक जावा ऑब्जेक्ट में बदलना होगा और इस प्रक्रिया को डीरिएरलाइज़ेशन कहा जाता है।
इस तरह से ऐसे कई उदाहरण हो सकते हैं जिनमें हमें जावा एप्लिकेशन के जीवनकाल में जावा ऑब्जेक्ट्स को क्रमांकित / डिसेर्बलाइज करने की आवश्यकता होती है।
क्रमांकन / deserialization की प्रक्रिया नीचे दी गई है:
जैसा कि ऊपर दिखाया गया है, क्रमांकन वस्तु को एक धारा में परिवर्तित करता है। Deserialization बाइट स्ट्रीम को जावा ऑब्जेक्ट में वापस कनवर्ट करता है।
क्रमबद्धता और निर्जनता का पूरा तंत्र प्लेटफॉर्म-स्वतंत्र है। इसका मतलब यह है कि हम ऑब्जेक्ट को एक प्लेटफॉर्म पर क्रमबद्ध कर सकते हैं और फिर इसे एक अलग प्लेटफॉर्म पर डिसेरलाइज़ कर सकते हैं।
जब हम कहते हैं कि हमने जावा ऑब्जेक्ट को सीरियल किया है, तो इसका मतलब है कि हमने ऑब्जेक्ट को एक फाइल में लिखने के लिए ObjectOutputStream विधि writeObject () कहा है।
कैसे एक स्ट्रिंग को बदलने के लिए सी + +
सार्वजनिक अंतिम शून्य लिखनाObect (ऑब्जेक्ट obj) IOException को फेंकता है
इसी तरह, डिसेरिअलाइज़ेशन के मामले में, हम ऑब्जेक्ट को संग्रहित फ़ाइल से डेटा को पढ़ने के लिए ObjectInputStream :: readObject () विधि कहते हैं।
सार्वजनिक अंतिम ऑब्जेक्ट readObject () IOException, ClassNotFoundException को फेंकता है
जावा सीरियल इंटरफ़ेस
जावा izable क्रमबद्ध करने योग्य ’नाम का इंटरफ़ेस प्रदान करता है, जिसके उपयोग से हम जावा में क्रमबद्धता और विचलन को लागू कर सकते हैं।
Serializable इंटरफ़ेस java.io पैकेज का एक हिस्सा है। यह एक मार्कर इंटरफ़ेस का एक उदाहरण है जिसकी हमने ऊपर और 0 पर चर्चा की है जिसमें कोई विधियाँ या सदस्य नहीं हैं। अनुक्रमिक इंटरफ़ेस so जावा कक्षाओं ’को चिह्नित करता है ताकि इन वर्गों की वस्तुओं को खुद को बनाए रखने की क्षमता मिल सके।
इसलिए जिस वर्ग की वस्तु को हमें बनाए रखने की आवश्यकता है, उसे सीरियल इंटरफ़ेस लागू करना चाहिए। तब इस वर्ग की वस्तु (सीरियल को लागू करने वाला इंटरफ़ेस) वर्ग ऑब्जेक्ट को क्रमबद्ध करने और डीसर्विलाइज़ करने के लिए क्रमशः writeObject () और readObject () विधियों का उपयोग करेगा।
ध्यान दें कि सभी आवरण वर्ग और स्ट्रिंग वर्ग java.io.Serializable डिफ़ॉल्ट रूप से लागू होते हैं।
हमें किसी वस्तु को सफलतापूर्वक प्रसारित करने के लिए निम्नलिखित शर्त को पूरा करना चाहिए:
- जिस वर्ग की वस्तुएं क्रमबद्ध हैं, उन्हें java.io.Serializable इंटरफ़ेस लागू करना होगा।
- वर्ग के सभी सदस्य क्षेत्र क्रमबद्ध होने चाहिए। यदि कोई विशेष क्षेत्र क्रमबद्ध नहीं है, तो हमें इसे क्षणिक के रूप में चिह्नित करना चाहिए।
इसके विपरीत, यदि कोई वर्ग java.io.Serializable इंटरफ़ेस को लागू करता है, तो यह धारावाहिक परिवर्तनशील नहीं है, अन्यथा केवल धारावाहिक परिवर्तनशील है।
कैसे जावा में एक वस्तु को सीरियलाइज़ करना और वर्णन करना है
जब हम जावा में किसी वस्तु को क्रमबद्ध करते हैं तो हम ऑब्जेक्ट को फाइल में लिखने के लिए ऑब्जेक्ट ऑउटपुट की राइटऑबजेक्ट विधि का उपयोग करते हैं।
जावा में ऑब्जेक्ट को डिस्क्राइब करने के लिए, हम फ़ाइल की सामग्री को पढ़ने के लिए ObjectInputStream के readObject () पद्धति का उपयोग करते हैं और उन्हें एक ऑब्जेक्ट में पढ़ते हैं।
इस उदाहरण में, हमारे पास एक छात्र वर्ग है जो सीरियल इंटरफ़ेस को लागू करता है। इसका मतलब यह है कि हम छात्र वर्ग की वस्तुओं को क्रमबद्ध या विचलित कर सकते हैं।
जावा प्रोग्राम की मुख्य विधि में, हम एक स्टूडेंट क्लास ऑब्जेक्ट बनाते हैं। फिर हम एक ObjectOutputStream बनाते हैं जो एक FileOutputStream ऑब्जेक्ट को इंगित करता है जो बदले में एक फाइल की ओर इशारा करता है जिसमें हमें स्टूडेंट ऑब्जेक्ट लिखने की आवश्यकता होती है। फिर हम राइटऑबजेक्ट () विधि को कहते हैं जो फ़ाइल को ऑब्जेक्ट लिखता है।
निर्दिष्ट फ़ाइल पर निर्दिष्ट ऑब्जेक्ट को सफलतापूर्वक लिखने पर, प्रोग्राम एक उपयुक्त आउटपुट संदेश देता है। फिर हम उपरोक्त प्रक्रिया को उल्टा करके वस्तु को निष्क्रिय कर देते हैं। सबसे पहले, हम एक ObjectOutputStream ऑब्जेक्ट बनाते हैं जिसमें हम उस फाइल को पढ़ते हैं जिसकी सामग्री को पढ़ना है।
फिर हम सामग्री को पढ़ने और छात्र ऑब्जेक्ट पर डालने के लिए readObject () विधि का उपयोग करते हैं। फिर हम स्टूडेंट ऑब्जेक्ट की सामग्री को प्रिंट करते हैं।
क्रमांकन / वर्णनकरण उदाहरण
निम्न जावा कार्यक्रम ऊपर चर्चा की गई के रूप में जावा में क्रमांकन / deserialization तंत्र को दर्शाता है।
import java.io.*; import java.io.Serializable; //Class Student implements class Student implements Serializable{ int id; String name; public Student(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of student class Student s1 =new Student(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); //Create a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('Eddie.txt')); Student s=(Student)in.readObject(); //print the data of the deserialized object System.out.println('Student object: ' + s.id+' '+s.name); //close the stream in.close(); }catch(Exception e){System.out.println(e);} } } आउटपुट:
ध्यान दें कि डिसेरिएलाइज़ेशन के बाद, हमें वही ऑब्जेक्ट मिलता है जिसे हमने पहले से सीरियल किया है क्योंकि हम फिर से उसी फाइल को खोलते हैं।
जावा क्षणिक खोजशब्द
एक क्षणिक कीवर्ड का उपयोग डेटा सदस्य को क्षणिक बनाने के लिए किया जाता है यानी हम इसे क्रमबद्ध नहीं करना चाहते हैं।
उदाहरण के लिए, निम्नलिखित वर्ग के कर्मचारी पर विचार करें। यहाँ हम अन्य क्षेत्रों के साथ कर्मचारी आईडी क्षेत्र है। अब अगर हम तय करते हैं कि कर्मचारी आईडी क्षेत्र को क्रमबद्ध नहीं किया जाना चाहिए, तो हम इसे 'क्षणिक' घोषित करते हैं।
एक उदाहरण जावा प्रोग्राम नीचे दिया गया है।
import java.io.*; class Employee implements Serializable{ transient int id; String name; public Employee(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of Employee class Employee s1 =new Employee(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); //Create a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('Eddie.txt')); Employee s=(Employee)in.readObject(); //print the data of the deserialized object System.out.println('Employee object: ' + s.id+' '+s.name); //close the stream in.close(); }catch(Exception e){System.out.println(e);} } } आउटपुट:
उपरोक्त कार्यक्रम में, हमने कर्मचारी वस्तु को क्रमबद्ध किया है। लेकिन ध्यान दें कि कर्मचारी वर्ग के कर्मचारी आईडी क्षेत्र को 'क्षणिक' घोषित किया गया है। अब क्रमांकन की जाँच करने के लिए, हम ऑब्जेक्ट को डिस्क्राइब करते हैं। आउटपुट कर्मचारी ऑब्जेक्ट को '0 एडी' के रूप में दिखाता है। इसका मतलब है कि कर्मचारी आईडी फ़ाइल में सहेजा नहीं गया था।
Java.io.NotSerializableException In Java
Java.io.NotSerializableException का अपवाद एक अपवाद है जिसे तब फेंक दिया जाता है जब वर्ग क्रमांकन के लिए योग्य नहीं होता है। वह वर्ग जो क्रमिक इंटरफ़ेस को कार्यान्वित नहीं करता है वह क्रमांकन के लिए अयोग्य हो जाता है।
नीचे दिए गए जावा प्रोग्राम NotSerializableException को प्रदर्शित करता है।
import java.io.*; class Employee { transient int id; String name; public Employee(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of Employee class Employee s1 =new Employee(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); }catch(Exception e){System.out.println(e);} } } आउटपुट:
जैसा कि उपरोक्त कार्यक्रम से देखा गया है, कर्मचारी वर्ग सीरियल इंटरफ़ेस लागू नहीं करता है। इसलिए, जब हम कर्मचारी वर्ग वस्तु को क्रमबद्ध करने की कोशिश करते हैं, तो NotSerializableException को फेंक दिया जाता है।
जावा में क्लोन करने योग्य इंटरफ़ेस
वस्तुओं के क्लोनिंग का अर्थ है वस्तुओं की प्रतिलिपि बनाना। जावा 'का उपयोग करके ऑब्जेक्ट क्लोनिंग का समर्थन करता है क्लोन करने योग्य ' इंटरफेस। क्लोन करने योग्य इंटरफ़ेस एक मार्कर इंटरफ़ेस है और java.lang पैकेज का एक हिस्सा है।
जब कोई वर्ग Cloneable इंटरफ़ेस को लागू करता है, तो इसका अर्थ है कि हम इस वर्ग की वस्तुओं को क्लोन कर सकते हैं। जावा के ऑब्जेक्ट क्लास में contains होता है क्लोन ()' तरीका। तो एक विशेष वर्ग द्वारा लागू क्लोन करने योग्य इंटरफ़ेस, क्लास इंस्टेंसेस की प्रतियां बनाने के लिए क्लोन () विधि को अधिकृत करता है।
यदि कोई वर्ग क्लोन करने योग्य इंटरफ़ेस को लागू नहीं करता है और फिर भी क्लोन () विधि को लागू करता है, तो अपवाद है CloneNotSupportedException जावा संकलक द्वारा फेंका गया है।
क्लोन करने योग्य इंटरफ़ेस को लागू करने वाली कक्षाओं को क्लोन () विधि को ओवरराइड करना चाहिए।
तो ऑब्जेक्ट क्लोनिंग क्या है?
ऑब्जेक्ट क्लोनिंग एक ऐसी प्रक्रिया है जिसका उपयोग करके हम ऑब्जेक्ट क्लास के क्लोन () पद्धति का उपयोग करके ऑब्जेक्ट की एक सटीक प्रतिलिपि बनाते हैं। क्लोन () विधि को ओवरराइड और इनवॉइस करने के लिए, क्लास को क्लोन करने योग्य इंटरफ़ेस को लागू करने की आवश्यकता है।
क्लोन () विधि का सामान्य सिंटैक्स नीचे दिया गया है:
संरक्षित ऑब्जेक्ट क्लोन () फेंकता CloneNotSupportedException
क्लोन () विधि, नए कीवर्ड का उपयोग करके एक नई वस्तु बनाने के लिए कम प्रसंस्करण समय के साथ ऑब्जेक्ट की एक सटीक प्रतिलिपि बनाता है।
नीचे जावा प्रोग्राम क्लोन () विधि और क्लोन करने योग्य इंटरफ़ेस के उपयोग को दर्शाता है।
class Student implements Cloneable{ int rollno; String name; //class constructor Student(int rollno,String name){ this.rollno=rollno; this.name=name; } //clone method public Object clone()throws CloneNotSupportedException{ return super.clone(); } } class Main{ public static void main(String args()){ try{ Student s1=new Student(101,'Lissa'); //clone the s1 object Student s2=(Student)s1.clone(); System.out.println('Original Student object: ' + s1.rollno+' '+s1.name); System.out.println('Cloned Student object: ' + s2.rollno+' '+s2.name); }catch(CloneNotSupportedException c){} } } आउटपुट:
इस कार्यक्रम में, हमारे पास एक छात्र वर्ग है जो क्लोन करने योग्य इंटरफ़ेस को लागू कर रहा है। यह सुपर.क्लोन () विधि को कॉल करके क्लोन () विधि को भी ओवरराइड करता है। मुख्य विधि में हम एक नया छात्र ऑब्जेक्ट बनाते हैं और फिर इस ऑब्जेक्ट पर क्लोन () विधि कहते हैं जो नए छात्र ऑब्जेक्ट को लौटाता है।
जावा में क्लोन ऐरे
हमने Arrays पर अपने ट्यूटोरियल में सरणियों की क्लोनिंग का पता लगाया। चूंकि जावा सरणियाँ डिफ़ॉल्ट रूप से क्लोन करने योग्य इंटरफ़ेस को लागू करती हैं, इसलिए उन्हें स्पष्ट रूप से लागू करने की आवश्यकता नहीं है। जब एक-आयामी सरणी को क्लोन किया जाता है, तो सरणी की एक गहरी प्रति उत्पन्न होती है। जब 2-आयामी सरणी को क्लोन किया जाता है, तो एक उथले प्रतिलिपि बनाई जाती है।
उथले प्रतिलिपि बनाना जावा में क्लोन () पद्धति का डिफ़ॉल्ट व्यवहार है। लेकिन ज्यादातर समय हम गहरी क्लोनिंग की इच्छा रखते हैं। गहरी क्लोनिंग में, हम सदस्य द्वारा वस्तु सदस्य की एक प्रति बनाते हैं और एक क्लोन बनाते हैं जो मूल वस्तु से स्वतंत्र होता है। तब क्लोन ऑब्जेक्ट में किए गए कोई भी परिवर्तन मूल ऑब्जेक्ट में प्रतिबिंबित नहीं होंगे।
निम्नलिखित जावा प्रोग्राम एक आयामी सरणी के क्लोनिंग को दर्शाता है।
class Main { public static void main(String args()) { //define an array int intArray() = {2,6,3,7,1,8}; //invoke clone () method on intArray int cloneArray() = intArray.clone(); //print the arrays. System.out.println('Original intArray:'); for (int i = 0; i आउटपुट:
जावा में क्लोन सूची
नीचे दिए गए कार्यक्रम से पता चलता है कि जावा में किसी सूची को क्लोन करने के लिए एक क्लोन () पद्धति का उपयोग कैसे करें।
import java.util.ArrayList; import java.util.Arrays; import java.util.List; // MyList Class implementing cloneable class MyList implements Cloneable { String name1; String name2; // Constructor MyList(String name1, String name2) { this.name1 = name1; this.name2 = name2; } // To print the objects in the desired format @Override public String toString() { return 'Hello ' + name1 + ',' + name2 + '
' ; } // Overriding the clone method @Override protected MyList clone() { return new MyList(name1 , name2); } } class Main { public static void main(String() args) { // Create a list List original = Arrays.asList( new MyList('Sydney','Rose'), new MyList('Joe','Ian')); // Create an empty list List cloned_list = new ArrayList(); // Loop through the list and clone each element for (MyList temp : original) cloned_list.add(temp.clone()); System.out.print(cloned_list); } } आउटपुट:
उपरोक्त कार्यक्रम में, हम देखते हैं कि हमने एक MyList वर्ग बनाया है जो क्लोन करने योग्य इंटरफ़ेस को लागू करता है और इस वर्ग के अंदर, हम क्लोन () पद्धति को ओवरराइड करते हैं जो हमें सूची को क्लोन करने में मदद करता है। मुख्य विधि में, हम तत्वों की एक सूची बनाते हैं और फिर सूची पर पुनरावृत्ति करके सूची के प्रत्येक तत्व को क्लोन करते हैं।
बार बार पूछे जाने वाले प्रश्न
Q # 1) जावा में मार्कर इंटरफ़ेस का उपयोग क्या है?
उत्तर: मार्कर इंटरफ़ेस जिसे ged टैग किए गए इंटरफ़ेस ’के रूप में भी जाना जाता है, वर्ग को टैग करता है और संकलक को सूचित करता है कि यह वर्ग एक विशेष व्यवहार को लागू कर सकता है।
Q # 2) जावा में सभी मार्कर इंटरफेस क्या हैं?
उत्तर: Serializable, Cloneable, और Remote ऐसे इंटरफेस हैं जो जावा में मार्कर इंटरफेस के उदाहरण हैं।
क्यू # 3) एक मार्कर इंटरफ़ेस सीरियल क्यों है?
उत्तर: क्रमबद्ध इंटरफ़ेस में कोई विधि या सदस्य चर नहीं है। यह एक खाली इंटरफ़ेस है जो इसे मार्कर इंटरफ़ेस के रूप में वर्गीकृत करता है।
Q # 4) रनर एक मार्कर इंटरफ़ेस है?
उत्तर: नहीं, रनरबल एक मार्कर इंटरफ़ेस नहीं है। रन करने योग्य इंटरफ़ेस खाली नहीं है और यह इसके अंदर एक रन () विधि घोषणा प्रदान करता है।
Q # 5) हमें क्लोन करने योग्य इंटरफ़ेस को लागू करने की आवश्यकता क्यों है?
उत्तर: किसी वर्ग के लिए क्लोन करने योग्य इंटरफ़ेस लागू करने से, हम इंगित करते हैं कि ऑब्जेक्ट क्लास के क्लोन () पद्धति का उपयोग करके इस वर्ग की वस्तुओं को क्लोन किया जा सकता है। यदि क्लोन () पद्धति का उपयोग करने वाला वर्ग क्लोन करने योग्य इंटरफ़ेस लागू नहीं करता है, तो अपवाद using CloneNotSupportedException ’को फेंक दिया जाता है।
निष्कर्ष
इस ट्यूटोरियल के साथ, हमने जावा में इंटरफेसेस पर अपनी चर्चा पूरी कर ली है। हमने इंटरफेस की अवधारणा, उनकी संरचना, परिभाषा, उपयोग, आदि पर चर्चा की है। हमने जावा जैसे तुलनात्मक, तुलनात्मक, मार्कर इंटरफेस आदि में कुछ महत्वपूर्ण इंटरफेस पर भी चर्चा की है।
इस ट्यूटोरियल में, हमने मार्कर इंटरफेस के दो उदाहरणों पर चर्चा की, अर्थात् सीरियल करने योग्य और क्लोन करने योग्य। किसी ऑब्जेक्ट को बनाए रखने के लिए एक सीरियल करने योग्य इंटरफ़ेस का उपयोग किया जाता है। क्लोन करने योग्य इंटरफ़ेस का उपयोग क्लास ऑब्जेक्ट को क्लोन करने के लिए किया जाता है। ये दोनों इंटरफेस मार्कर इंटरफेस हैं यानी ये खाली हैं।
लेकिन जब एक वर्ग उन्हें लागू करता है, तो वे संकेत देते हैं कि संकलक उन्हें लागू करने वाले वर्गों से कुछ विशेष व्यवहार की उम्मीद कर सकता है।
उदाहरण के लिए, जब एक वर्ग एक सीरियल इंटरफ़ेस लागू करता है तो हम श्रेणी वस्तुओं को क्रमबद्ध या निष्क्रिय कर सकते हैं और उनके राज्य को बचा सकते हैं / पुनः प्राप्त कर सकते हैं।
एक क्लोन इंटरफ़ेस को लागू करने वाला एक वर्ग इंगित करता है कि हम इस वर्ग की वस्तुओं को क्लोन कर सकते हैं। क्लोन () पद्धति का डिफ़ॉल्ट कार्यान्वयन ऑब्जेक्ट की उथली प्रतिलिपि बनाता है जबकि हम गहरी प्रतिलिपि बनाने के लिए क्लोन () विधि को ओवरराइड कर सकते हैं।
=> यहां पूर्ण जावा प्रशिक्षण श्रृंखला का अन्वेषण करें
अनुशंसित पाठ
- जावा में इंटरफ़ेस सेट करें: उदाहरणों के साथ जावा सेट ट्यूटोरियल
- ListIterator Interface जावा में उदाहरणों के साथ
- जावा परिनियोजन: जावा जार फ़ाइल का निर्माण और निष्पादन
- और जावा - और इसके कार्यान्वयन और परिभाषाएँ
- जावा बेसिक्स: जावा सिंटैक्स, जावा क्लास और कोर जावा कॉन्सेप्ट
- जावा क्लास बनाम ऑब्जेक्ट - जावा में क्लास और ऑब्जेक्ट का उपयोग कैसे करें
- जावा वर्चुअल मशीन: जावा एप्लीकेशन चलाने में JVM कैसे मदद करता है
- जावा में तुलनीय और तुलनात्मक इंटरफेस
