java reflection tutorial with examples
यह वीडियो ट्यूटोरियल बताता है कि प्रतिबिंब क्या है और प्रतिबिंब एपीआई का उपयोग करके इसे कैसे लागू किया जाए:
जावा में परावर्तन, रनटाइम के दौरान किसी प्रोग्राम के व्यवहार का निरीक्षण और परिवर्तन करना है।
इस रिफ्लेक्शन एपीआई की मदद से आप रनटाइम के दौरान क्लासेस, कंस्ट्रक्टर्स, मॉडिफायर्स, फील्ड्स, मेथड्स और इंटरफेस का निरीक्षण कर सकते हैं। उदाहरण के लिए, आप कक्षा का नाम प्राप्त कर सकते हैं या आप कक्षा के निजी सदस्यों का विवरण प्राप्त कर सकते हैं।
हमारे पूरे के माध्यम से पढ़ें जावा प्रशिक्षण श्रृंखला जावा अवधारणाओं पर अधिक जानकारी के लिए।
यहाँ जावा प्रतिबिंब पर एक वीडियो ट्यूटोरियल है:
आप क्या सीखेंगे:
जावा में प्रतिबिंब
हम जानते हैं कि किसी दिए गए वर्ग में हम संकलन समय पर इसके गुणों और विधियों को संशोधित कर सकते हैं और ऐसा करना बहुत आसान है। क्या गुण और विधियाँ अनाम हैं या उनके नाम हैं, उन्हें संकलन समय के दौरान हमारी इच्छा पर बदला जा सकता है।
लेकिन हम फ्लाई पर रनटाइम पर इन वर्गों या विधियों या फ़ील्ड को नहीं बदल सकते। दूसरे शब्दों में, विशेष रूप से अज्ञात वस्तुओं के लिए रनटाइम पर विभिन्न प्रोग्रामिंग घटकों के व्यवहार को बदलना बहुत मुश्किल है।
जावा प्रोग्रामिंग लैंग्वेज नामक एक सुविधा प्रदान करती है 'प्रतिबिंब' जो हमें रनटाइम पर किसी वर्ग या क्षेत्र या विधि के रनटाइम व्यवहार को संशोधित करने की अनुमति देता है।
इस प्रकार परावर्तन को एक के रूप में परिभाषित किया जा सकता है “रन टाइम में किसी अज्ञात वस्तु के रनटाइम व्यवहार का निरीक्षण और संशोधन करने की तकनीक। एक वस्तु एक वर्ग, एक क्षेत्र या एक विधि हो सकती है। '
प्रतिबिंब जावा द्वारा प्रदान किया गया 'एप्लीकेशन प्रोग्रामिंग इंटरफेस' (एपीआई) है।
'प्रतिबिंब' प्रक्रिया को नीचे दर्शाया गया है।
उपरोक्त प्रतिनिधित्व में, हम देख सकते हैं कि हमारे पास एक अज्ञात वस्तु है। फिर हम इस ऑब्जेक्ट पर रिफ्लेक्शन एपीआई का उपयोग करते हैं। परिणामस्वरूप, हम रनटाइम पर इस ऑब्जेक्ट के व्यवहार को संशोधित कर सकते हैं।
इस प्रकार हम ऑब्जेक्ट के व्यवहार को संशोधित करने के उद्देश्य से अपने कार्यक्रमों में रिफ्लेक्शन एपीआई का उपयोग कर सकते हैं। ऑब्जेक्ट कुछ भी हो सकते हैं जैसे विधियाँ, इंटरफेस, क्लास आदि। हम इन ऑब्जेक्ट्स का निरीक्षण करते हैं और फिर परावर्तन एपीआई का उपयोग करके रनटाइम पर अपने व्यवहार को बदलते हैं।
जावा में, 'java.lang' और 'java.lang.reflect' दो पैकेज हैं जो प्रतिबिंब के लिए कक्षाएं प्रदान करते हैं। विशेष वर्ग 'java.lang.Class' मेटाडेटा को निकालने के लिए तरीके और गुण प्रदान करता है जिसका उपयोग करके हम कक्षा के व्यवहार का निरीक्षण और संशोधन कर सकते हैं।
हम उपर्युक्त पैकेजों द्वारा प्रदान की गई रिफ्लेक्शन एपीआई का उपयोग क्लास और उसके सदस्यों को रनटाइम के दौरान फ़ील्ड, मेथड, कंस्ट्रक्टर, आदि को संशोधित करने के लिए करते हैं। प्रतिबिंब एपीआई की एक विशिष्ट विशेषता यह है कि हम निजी डेटा सदस्यों या कक्षा के तरीकों में भी हेरफेर कर सकते हैं।
परावर्तन एपीआई मुख्य रूप से उपयोग किया जाता है:
- चिंतन का उपयोग मुख्य रूप से डिबगिंग टूल्स, जेयूनाइट, और चौखटे में किया जाता है, जो रनटाइम में व्यवहार का निरीक्षण और परिवर्तन करता है।
- आईडीई (एकीकृत विकास पर्यावरण) जैसे ग्रहण आईडीई, नेटबीन्स, आदि।
- परीक्षण उपकरण आदि
- इसका उपयोग तब किया जाता है, जब आपके आवेदन में तृतीय-पक्ष लाइब्रेरी होती है और जब आप उपलब्ध कक्षाओं और विधियों के बारे में जानना चाहते हैं।
जावा में प्रतिबिंब एपीआई
प्रतिबिंब एपीआई का उपयोग करते हुए, हम निम्नलिखित संस्थाओं पर प्रतिबिंब को लागू कर सकते हैं:
- मैदान : फ़ील्ड वर्ग के पास ऐसी जानकारी होती है, जिसका उपयोग हम एक चर या एक क्षेत्र जैसे डेटाटाइप (इंट, डबल, स्ट्रिंग, इत्यादि), एक्सेस मॉडिफायर (निजी, सार्वजनिक, संरक्षित, आदि), नाम (पहचानकर्ता) और मूल्य के लिए करते हैं।
- तरीका : विधि वर्ग विधि की पहुंच संशोधक, विधि वापसी प्रकार, विधि का नाम, विधि पैरामीटर प्रकार और विधि द्वारा उठाए गए अपवाद प्रकार जैसी जानकारी निकालने में हमारी मदद कर सकता है।
- निर्माता : कंस्ट्रक्टर वर्ग क्लास कंस्ट्रक्टर के बारे में जानकारी देता है जिसमें कंस्ट्रक्टर एक्सेस मॉडिफायर, कंस्ट्रक्टर का नाम और पैरामीटर प्रकार शामिल हैं।
- संपादित करें : संशोधक वर्ग हमें एक विशिष्ट पहुँच संशोधक के बारे में जानकारी देता है।
उपरोक्त सभी कक्षाएं java.lang.reflect पैकेज का एक हिस्सा हैं। अगला, हम इन वर्गों में से प्रत्येक पर चर्चा करेंगे और इन वर्गों पर प्रतिबिंब प्रदर्शित करने के लिए प्रोग्रामिंग उदाहरणों का उपयोग करेंगे।
कक्षा java.lang.Class के साथ शुरू करते हैं।
java.lang.Class क्लास
Java.lang। वर्ग रनटाइम पर कक्षाओं और वस्तुओं के बारे में सभी जानकारी और डेटा रखता है। यह प्रतिबिंब के लिए उपयोग किया जाने वाला मुख्य वर्ग है।
वर्ग java.lang.Class प्रदान करता है:
- रन टाइम में क्लास मेटाडेटा को पुनः प्राप्त करने के तरीके।
- रन टाइम में किसी वर्ग के व्यवहार का निरीक्षण और संशोधन करने के तरीके।
Java.lang.Class ऑब्जेक्ट बनाएँ
हम निम्नलिखित विकल्पों में से एक का उपयोग करके java.lang.Class की वस्तुएँ बना सकते हैं।
सभी ईमेल साइट क्या हैं
# 1) .class एक्सटेंशन
.Class एक्सटेंशन का उपयोग करके क्लास का ऑब्जेक्ट बनाने का पहला विकल्प है।
उदाहरण के लिए,यदि टेस्ट एक वर्ग है, तो हम निम्नानुसार एक क्लास ऑब्जेक्ट बना सकते हैं:
Class obj_test = Test.class; फिर हम प्रतिबिंब का उपयोग करने के लिए obj_test का उपयोग कर सकते हैं क्योंकि इस ऑब्जेक्ट में कक्षा टेस्ट के बारे में सभी जानकारी होगी।
# 2) forName () विधि
forName () विधि वर्ग का नाम एक तर्क के रूप में लेती है और क्लास ऑब्जेक्ट लौटाती है।
उदाहरण के लिए,परीक्षण वर्ग का उद्देश्य निम्नानुसार बनाया जा सकता है:
class obj_test = Class.forName (“Test”); # 3) getClas () विधि
getClass () विधि java.lang.Class ऑब्जेक्ट प्राप्त करने के लिए एक वर्ग की वस्तु का उपयोग करती है।
उदाहरण के लिए,निम्नलिखित कोड पर विचार करें:
Test obj = new Test (); Class obj_test = obj.getClass (); पहली पंक्ति में, हमने टेस्ट क्लास का एक ऑब्जेक्ट बनाया। फिर इस ऑब्जेक्ट का उपयोग करके हमने java.lang.Class की ऑब्जेक्ट obj_test प्राप्त करने के लिए 'getClass ()' विधि को बुलाया।
सुपर क्लास और एक्सेस मॉडिफायर प्राप्त करें
java.lang.class एक तरीका 'getSuperClass ()' प्रदान करता है जिसका उपयोग किसी भी वर्ग के सुपरक्लास को प्राप्त करने के लिए किया जाता है।
इसी तरह, यह एक विधि getModifier () प्रदान करता है जो वर्ग के एक्सेस संशोधक को लौटाता है।
नीचे दिया गया उदाहरण getSuperClass () विधि को प्रदर्शित करता है।
import java.lang.Class; import java.lang.reflect.*; //define Person interface interface Person { public void display(); } //declare class Student that implements Person class Student implements Person { //define interface method display public void display() { System.out.println('I am a Student'); } } class Main { public static void main(String() args) { try { // create an object of Student class Student s1 = new Student(); // get Class object using getClass() Class obj = s1.getClass(); // get the superclass of Student Class superClass = obj.getSuperclass(); System.out.println('Superclass of Student Class: ' + superClass.getName()); } catch(Exception e) { e.printStackTrace(); } } }उत्पादन
उपरोक्त प्रोग्रामिंग उदाहरण में, एक इंटरफ़ेस पर्सन को एक एकल विधि) डिस्प्ले () ’के साथ परिभाषित किया गया है। फिर हम व्यक्ति इंटरफ़ेस को लागू करने वाले छात्र वर्ग को परिभाषित करते हैं। मुख्य विधि में, हम क्लास ऑब्जेक्ट को प्राप्त करने के लिए getClass () विधि का उपयोग करते हैं और फिर getSuperClass () विधि का उपयोग करके छात्र ऑब्जेक्ट के मूल या सुपरक्लास तक पहुंचते हैं।
इंटरफेस प्राप्त करें
यदि वर्ग कुछ इंटरफेस को लागू करता है, तो हम इन इंटरफेस को java.lang.Class की getInterfaces () विधि का उपयोग करके प्राप्त कर सकते हैं। इसके लिए, हमें जावा वर्ग पर एक प्रतिबिंब बनाना होगा।
नीचे प्रोग्रामिंग उदाहरण जावा रिफ्लेक्शन में getInterfaces () पद्धति के उपयोग को दर्शाया गया है।
import java.lang.Class; import java.lang.reflect.*; //define Interface Animals and PetAnimals interface Animals { public void display(); } interface PetAnimals { public void makeSound(); } //define a class Dog that implements above interfaces class Dog implements Animals, PetAnimals { //define interface method display public void display() { System.out.println('This is a PetAnimal::Dog'); } //define interface method makeSound public void makeSound() { System.out.println('Dog makes sound::Bark bark'); } } class Main { public static void main(String() args) { try { // create an object of Dog class Dog dog = new Dog(); // get class object Class obj = dog.getClass(); // get the interfaces implemented by Dog Class() objInterface = obj.getInterfaces(); System.out.println('Class Dog implements following interfaces:'); //print all the interfaces implemented by class Dog for(Class citem : objInterface) { System.out.println('Interface Name: ' + citem.getName()); } } catch(Exception e) { e.printStackTrace(); } } }उत्पादन
उपरोक्त कार्यक्रम में, हमने दो इंटरफेस यानि एनिमल्स और पेटेमनिम्स को परिभाषित किया है। फिर हम एक क्लास डॉग को परिभाषित करते हैं, जो इन दोनों इंटरफेस को लागू करता है।
मुख्य विधि में, हम java.lang.Class में क्लास डॉग की वस्तु को पुनः प्राप्त करते हैं। फिर हम क्लास डॉग द्वारा लागू किए गए इंटरफेस को पुनः प्राप्त करने के लिए getInterfaces () विधि का उपयोग करते हैं।
प्रतिबिंब: फ़ील्ड मान प्राप्त करें
जैसा कि पहले ही बताया गया है कि java.lang.reflect फ़ील्ड वर्ग प्रदान करता है जो हमें कक्षा के क्षेत्र या डेटा सदस्यों को प्रतिबिंबित करने में मदद करता है।
नीचे सूचीबद्ध तरीके फ़ील्ड फ़ील्ड द्वारा किसी क्षेत्र के प्रतिबिंब के लिए प्रदान किए गए तरीके हैं।
| तरीका | विवरण |
|---|---|
| getField ('फ़ील्डनाम') | निर्दिष्ट फ़ील्ड नाम के साथ फ़ील्ड (सार्वजनिक) लौटाता है। |
| getFields () | सभी सार्वजनिक क्षेत्रों (दोनों वर्ग और सुपरक्लास के लिए) लौटाता है। |
| getDeclaredFields () | वर्ग के सभी क्षेत्रों को पुनः प्राप्त करता है। |
| getModifier () | फ़ील्ड के पहुँच संशोधक का पूर्णांक प्रतिनिधित्व लौटाता है। |
| सेट (classObject, मूल्य) | क्षेत्र के लिए निर्दिष्ट मान असाइन करता है। |
| प्राप्त करें (classObject) | फ़ील्ड मान प्राप्त करता है। |
| असफल (बूलियन) | सच पास करके निजी क्षेत्र को सुलभ बनाएं। |
| getDeclaredField ('फ़ील्डनाम') | निर्दिष्ट नाम के साथ फ़ील्ड लौटाता है। |
नीचे दिए गए दो प्रतिबिंब उदाहरण हैं जो सार्वजनिक और निजी क्षेत्र पर प्रतिबिंब प्रदर्शित करते हैं।
नीचे दिया गया जावा प्रोग्राम सार्वजनिक क्षेत्र पर प्रतिबिंब को प्रदर्शित करता है।
import java.lang.Class; import java.lang.reflect.*; class Student { public String StudentName; } class Main { public static void main(String() args) { try{ Student student = new Student(); // get an object of the class Class Class obj = student.getClass(); // provide field name and get the field info Field student_field = obj.getField('StudentName'); System.out.println('Details of StudentName class field:'); // set the value of field student_field.set(student, 'Lacey'); // get the access modifier of StudentName int mod1 = student_field.getModifiers(); String modifier1 = Modifier.toString(mod1); System.out.println('StudentName Modifier::' + modifier1); // get the value of field by converting in String String typeValue = (String)student_field.get(student); System.out.println('StudentName Value::' + typeValue); } catch(Exception e) { e.printStackTrace(); } } }उत्पादन
इस कार्यक्रम में, हमने एक क्लास 'स्टूडेंट' घोषित किया है, जिसमें पब्लिक फील्ड स्टूडेंटनाम है। फिर फील्ड क्लास के एपीआई इंटरफ़ेस का उपयोग करते हुए, हम छात्रनाम पर प्रतिबिंब का प्रदर्शन करते हैं और इसके एक्सेस संशोधक और मूल्य को पुनः प्राप्त करते हैं।
अगला कार्यक्रम कक्षा के एक निजी क्षेत्र पर प्रतिबिंब करता है। संचालन समान हैं सिवाय इसके कि निजी क्षेत्र के लिए एक अतिरिक्त फ़ंक्शन कॉल है। हमें निजी क्षेत्र के लिए setAccessible (सच) को कॉल करना होगा। फिर हम सार्वजनिक क्षेत्र के समान इस फ़ील्ड पर प्रतिबिंब प्रदर्शन करते हैं।
import java.lang.Class; import java.lang.reflect.*; class Student { private String rollNo; } class Main { public static void main(String() args) { try { Student student = new Student(); // get the object for class Student in a Class. Class obj = student.getClass(); // access the private field Field field2 = obj.getDeclaredField('rollNo'); // make the private field accessible field2.setAccessible(true); // set the value of rollNo field2.set(student, '27'); System.out.println('Field Information of rollNo:'); // get the access modifier of rollNo int mod2 = field2.getModifiers(); String modifier2 = Modifier.toString(mod2); System.out.println('rollNo modifier::' + modifier2); // get the value of rollNo converting in String String rollNoValue = (String)field2.get(student); System.out.println('rollNo Value::' + rollNoValue); } catch(Exception e) { e.printStackTrace(); } } }उत्पादन
परावर्तन: विधि
कक्षा के क्षेत्रों के समान, हम क्लास के तरीकों पर भी परफॉर्म कर सकते हैं और रन टाइम में उनके व्यवहार को संशोधित कर सकते हैं। इसके लिए हम java.lang.reflect पैकेज के मेथड क्लास का उपयोग करते हैं।
नीचे सूचीबद्ध किए गए कार्य कक्षा विधि के प्रतिबिंबन के लिए विधि वर्ग द्वारा प्रदान किए गए हैं।
| तरीका | विवरण |
|---|---|
| getMethods () | वर्ग और उसके सुपरक्लास में परिभाषित सभी सार्वजनिक तरीकों को पुनः प्राप्त करता है। |
| getDeclaredMethod () | क्लास में घोषित किए गए रिटर्न के तरीके। |
| getName () | विधि के नाम लौटाता है। |
| getModifiers () | विधि के एक्सेस संशोधक का पूर्णांक प्रतिनिधित्व दर्शाता है। |
| getReturnType () | विधि वापसी प्रकार देता है। |
नीचे दिए गए उदाहरण में उपरोक्त एपीआई का उपयोग करके जावा में वर्ग विधियों का प्रतिबिंब दिखाया गया है।
import java.lang.Class; import java.lang.reflect.*; //declare a class Vehicle with four methods class Vehicle { public void display() { System.out.println('I am a Vehicle!!'); } protected void start() { System.out.println('Vehicle Started!!!'); } protected void stop() { System.out.println('Vehicle Stopped!!!'); } private void serviceVehicle() { System.out.println('Vehicle serviced!!'); } }class Main { public static void main(String() args) { try { Vehicle car = new Vehicle(); // create an object of Class Class obj = car.getClass(); // get all the methods using the getDeclaredMethod() in an array Method() methods = obj.getDeclaredMethods(); // for each method get method info for(Method m : methods) { System.out.println('Method Name: ' + m.getName()); // get the access modifier of methods int modifier = m.getModifiers(); System.out.print('Modifier: ' + Modifier.toString(modifier) + ' '); // get the return type of method System.out.print('Return Type: ' + m.getReturnType()); System.out.println('
'); } } catch(Exception e) { e.printStackTrace(); } } }उत्पादन
उपरोक्त कार्यक्रम में, हम देखते हैं कि विधि getDeclaredMethods वर्ग द्वारा घोषित तरीकों की सरणी देता है। फिर हम इस सरणी के माध्यम से पुनरावृत्ति करते हैं और प्रत्येक विधि की जानकारी प्रदर्शित करते हैं।
परावर्तन: कंस्ट्रक्टर
हम जावा वर्ग के कंस्ट्रक्टर्स का निरीक्षण और संशोधन करने के लिए java.lang.reflect पैकेज के 'कंस्ट्रक्टर' वर्ग का उपयोग कर सकते हैं।
कंस्ट्रक्टर वर्ग इस उद्देश्य के लिए निम्नलिखित तरीके प्रदान करता है।
| तरीका | विवरण |
|---|---|
| getConstructors () | वर्ग और उसके सुपरक्लास में घोषित सभी निर्माणकर्ताओं को लौटाता है। |
| getDeclaredConstructor () | सभी घोषित निर्माणकर्ताओं को लौटाता है। |
| getName () | निर्माणकर्ता का नाम वापस लेता है। |
| getModifiers () | कन्स्ट्रक्टर्स के एक्सेस संशोधक के पूर्णांक प्रतिनिधित्व को लौटाता है। |
| getParameterCount () | एक निर्माता के लिए मापदंडों की कुल संख्या देता है। |
नीचे दिया गया प्रतिबिंब उदाहरण जावा में एक वर्ग के निर्माणकर्ताओं के प्रतिबिंब को प्रदर्शित करता है। विधि प्रतिबिंब की तरह, यहाँ भी getDeclaredConstructors विधि एक वर्ग के लिए निर्माणकर्ताओं की एक सरणी देती है। फिर हम प्रत्येक कंस्ट्रक्टर के बारे में जानकारी प्रदर्शित करने के लिए इस कंस्ट्रक्टर एरे से आगे बढ़ते हैं।
import java.lang.Class; import java.lang.reflect.*; //declare a class Person with three constructors class Person { public Person() { } //constructor with no parameters public Person(String name) { } //constructor with 1 parameter private Person(String name, int age) {} //constructor with 2 parameters } class Main { public static void main(String() args) { try { Person person = new Person(); Class obj = person.getClass(); // get array of constructors in a class using getDeclaredConstructor() Constructor() constructors = obj.getDeclaredConstructors(); System.out.println('Constructors for Person Class:'); for(Constructor c : constructors) { // get names of constructors System.out.println('Constructor Name: ' + c.getName()); // get access modifier of constructors int modifier = c.getModifiers(); System.out.print ('Modifier: ' + Modifier.toString(modifier) + ' '); // get the number of parameters in constructors System.out.println('Parameters: ' + c.getParameterCount()); //if there are parameters, get parameter type of each parameter if(c.getParameterCount() > 0){ Class() paramList=c.getParameterTypes(); System.out.print ('Constructor parameter types :'); for (Class class1 : paramList) { System.out.print(class1.getName() +' '); } } System.out.println('
'); } } catch(Exception e) { e.printStackTrace(); } } }उत्पादन
प्रतिबिंब की कमियां
प्रतिबिंब शक्तिशाली है, लेकिन अंधाधुंध उपयोग नहीं किया जाना चाहिए। यदि प्रतिबिंब का उपयोग किए बिना इसे संचालित करना संभव है, तो इसका उपयोग करने से बचना बेहतर है।
नीचे सूचीबद्ध परावर्तन की कुछ कमियां हैं:
- प्रदर्शन ओवरहेड: हालांकि प्रतिबिंब एक शक्तिशाली विशेषता है, चिंतनशील संचालन में अभी भी गैर-चिंतनशील संचालन की तुलना में धीमा प्रदर्शन है। इसलिए हमें प्रदर्शन-महत्वपूर्ण अनुप्रयोगों में प्रतिबिंबों का उपयोग करने से बचना चाहिए।
- सुरक्षा प्रतिबंध: चूंकि प्रतिबिंब एक रनटाइम सुविधा है, इसलिए इसे रन-टाइम अनुमतियों की आवश्यकता हो सकती है। तो उन अनुप्रयोगों के लिए जिनके लिए एक प्रतिबंधित सुरक्षा सेटिंग में कोड को निष्पादित करने की आवश्यकता होती है, फिर प्रतिबिंब का कोई फायदा नहीं हो सकता है।
- आंतरिक का एक्सपोजर: प्रतिबिंब का उपयोग करके, हम एक कक्षा में निजी क्षेत्रों और विधियों का उपयोग कर सकते हैं। इस प्रकार प्रतिबिंब एब्स्ट्रैक्शन को तोड़ता है जो कोड को असंगत और दुष्क्रियाशील बना सकता है।
बार बार पूछे जाने वाले प्रश्न
क्यू # 1) जावा में प्रतिबिंब का उपयोग क्यों किया जाता है?
उत्तर: परावर्तन के उपयोग से हम रन टाइम पर कक्षाओं, इंटरफेस, कंस्ट्रक्टर, फ़ील्ड्स और विधियों का निरीक्षण कर सकते हैं, भले ही वे संकलन के समय अनाम हों। यह निरीक्षण हमें रनटाइम पर इन संस्थाओं के व्यवहार को संशोधित करने की अनुमति देता है।
क्यू # 2) परावर्तन का उपयोग कहाँ किया जाता है?
उत्तर: परावर्तन का उपयोग उन रूपरेखाओं को लिखने में किया जाता है जो उपयोगकर्ता द्वारा परिभाषित कक्षाओं के साथ परस्पर क्रिया करती हैं, जिसमें प्रोग्रामर को यह भी पता नहीं होता है कि कक्षाएँ या अन्य संस्थाएँ क्या होंगी।
क्यू # 3) क्या जावा प्रतिबिंब धीमा है?
उत्तर: हां, यह नॉन-रिफ्लेक्शन कोड की तुलना में धीमा है।
क्यू # 4) क्या जावा प्रतिबिंब खराब है?
उत्तर: एक तरह से, हाँ। सबसे पहले, हम संकलन-समय सुरक्षा खो देते हैं। संकलित समय सुरक्षा के बिना, हम अंत समय त्रुटियों को प्राप्त कर सकते हैं जो अंत उपयोगकर्ताओं को प्रभावित कर सकते हैं। त्रुटि को डीबग करना भी मुश्किल होगा।
क्यू # 5) जावा में रिफ्लेक्शन को कैसे रोकें?
उत्तर: हम केवल गैर-प्रतिबिंब संचालन लिखकर प्रतिबिंब का उपयोग करने से बचते हैं। या हो सकता है कि हम कुछ सामान्य तंत्रों का उपयोग कर सकते हैं जैसे प्रतिबिंब के साथ कस्टम सत्यापन।
जावा प्रतिबिंब के बारे में अधिक
java.lang.reflect पैकेज में प्रतिबिंब करने के लिए कक्षाएं और इंटरफेस हैं। और java.lang.class को प्रतिबिंब के लिए प्रवेश बिंदु के रूप में इस्तेमाल किया जा सकता है।
क्लास ऑब्जेक्ट कैसे प्राप्त करें:
1. यदि आपके पास किसी वस्तु का उदाहरण है,
वर्ग c = obj.getclass ();
2. यदि आप कक्षा का प्रकार जानते हैं,
वर्ग c = type.getClass ();
3. यदि आप वर्ग का नाम जानते हैं,
कक्षा c = Class.forName ('com.demo.Mydemoclass');
कक्षा के सदस्यों को कैसे प्राप्त करें:
कक्षा के सदस्य फ़ील्ड (वर्ग चर) और विधियाँ हैं।
- getFields () - निजी क्षेत्रों को छोड़कर सभी क्षेत्र प्राप्त करते थे।
- getDeclaredField () - निजी खेतों को प्राप्त करते थे।
- getDeclaredFields () - निजी और सार्वजनिक क्षेत्रों को प्राप्त करने के लिए उपयोग किया जाता है।
- getMethods () - निजी तरीकों को छोड़कर सभी तरीकों को प्राप्त करने के लिए उपयोग किया जाता है।
- getDeclaredMethods () सार्वजनिक और निजी तरीकों को पाने के लिए इस्तेमाल किया।
डेमो कार्यक्रम:
परावर्तन हेल्पर.जावा:
यह वह वर्ग है जहां हम प्रतिबिंब एपीआई का उपयोग करके निरीक्षण करने जा रहे हैं।
जावा में डबल क्या करता है
class ReflectionHelper { private int age; private String name; public String deptName; public int empID; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDeptName() { return deptName; } public void setDeptName(String deptName) { this.deptName = deptName; } } 
परावर्तनमदेव.जवा
public class ReflectionDemo { public static void main(String() args) throws NoSuchFieldException, SecurityException { //get the class Class ReflectionHelperclass=ReflectionHelper.class; //get the name of the class String className = ReflectionHelperclass.getName(); System.out.println('className=='+className); System.out.println('getModifiers'+ReflectionHelperclass.getModifier s()); System.out.println('getSuperclass'+ReflectionHelperclass.getSupercla ss()); System.out.println('getPackage'+ReflectionHelperclass.getPackage()); Field() fields =ReflectionHelperclass.getFields(); //getting only the public fields for(Field oneField : fields) { Field field = ReflectionHelperclass.getField(oneField.getName()); String fieldname = field.getName(); System.out.println('only the public fieldnames:::::'+fieldname); } //getting all the fields of the class Field() privatefields =ReflectionHelperclass.getDeclaredFields(); for(Field onefield : privatefields) { Field field = ReflectionHelperclass.getDeclaredField(onefield.getName()); String fieldname = field.getName(); System.out.println('all the fieldnames in the class:::'+fieldname); } Method() methods =ReflectionHelperclass.getDeclaredMethods(); for(Method m: methods) { System.out.println('methods::::'+m.getName()); } }} 
निष्कर्ष
इस ट्यूटोरियल ने जावा में रिफ्लेक्शन एपीआई के बारे में विस्तार से बताया। हमने देखा कि प्रतिबिंब के कुछ कमियों के साथ कक्षाओं, इंटरफेस, फ़ील्ड्स, विधियों और कंस्ट्रक्टरों का प्रतिबिंब कैसे प्रदर्शन किया जाए।
परावर्तन जावा में एक अपेक्षाकृत उन्नत विशेषता है, लेकिन इसे प्रोग्रामर द्वारा भाषा पर गढ़ रखने के लिए उपयोग किया जाना चाहिए। ऐसा इसलिए है क्योंकि यह सावधानी के साथ उपयोग नहीं किए जाने पर अप्रत्याशित त्रुटियां और परिणाम हो सकता है।
हालांकि प्रतिबिंब शक्तिशाली है, इसका उपयोग सावधानी से किया जाना चाहिए। बहरहाल, प्रतिबिंब का उपयोग करके हम उन अनुप्रयोगों को विकसित कर सकते हैं जो रनटाइम तक कक्षाओं और अन्य संस्थाओं से अनजान हैं।
=> यहाँ जावा शुरुआती गाइड पर एक नज़र रखना।
अनुशंसित पाठ
- जावा स्कैनर क्लास ट्यूटोरियल उदाहरण के साथ
- उदाहरण के लिए जावा इंटेगर और जावा बिगइंटर क्लास
- जावा ट्यूटोरियल फॉर बिगिनर्स: 100+ हैंड्स-ऑन जावा वीडियो ट्यूटोरियल
- जावा प्रोग्रामिंग भाषा का परिचय - वीडियो ट्यूटोरियल
- जावा वेक्टर क्या है | उदाहरणों के साथ जावा वेक्टर क्लास ट्यूटोरियल
- उदाहरण के साथ जावा इंटरफेस और एब्सट्रैक्ट क्लास ट्यूटोरियल
- जावा सबस्ट्रिंग () विधि - उदाहरण के साथ ट्यूटोरियल
- जावा कलेक्शंस फ्रेमवर्क (JCF) ट्यूटोरियल