Mi a Reflection a Java-ban?
A Java Reflection az osztály összes képességének futás közbeni elemzésének és módosításának folyamata. A Java Reflection API az osztály és tagjainak manipulálására szolgál, amelyek futás közben tartalmaznak mezőket, módszereket, konstruktort stb.
A Java-ban a reflektálás API egyik előnye, hogy manipulálni tudja az osztály privát tagjait is.
A java.lang.reflect csomag számos osztályt kínál a java reflexió megvalósításához. A java.lang.Class osztály metódusai egy adott osztály teljes metaadatainak összegyűjtésére szolgálnak.
Ebben az oktatóanyagban megtanulja-
- Mi a reflexió
- Osztály a java.lang.reflect csomagban
- A java.lang.Class alkalmazásában alkalmazott módszerek
- Hogyan lehet teljes körű információt szerezni egy osztályról
- 1. példa: Hogyan lehet megszerezni az osztály metaadatait
- 2. példa: A változó metaadatainak megszerzése
- 3. példa: A módszer metaadatainak megszerzése
- 4. példa: Hogyan lehet megszerezni a kivitelezők metaadatait
Osztály a java.lang.reflect csomagban
Az alábbiakban felsoroljuk a Java osztályok listáját a java.lang.package alkalmazásban a reflexió-
- Mező : Ez az osztály olyan deklaratív információk gyűjtésére szolgál, mint például az adattípus, a hozzáférés-módosító, a változó neve és értéke.
- Módszer : Ezt az osztályt olyan deklaratív információk gyűjtésére használják, mint a hozzáférés-módosító, a visszatérés típusa, a név, a paramétertípusok és a módszer típusa.
- Konstruktor : Ez az osztály olyan deklaratív információk gyűjtésére szolgál, mint például a konstruktor hozzáférés-módosítója, neve és paramétertípusai.
- Módosító : Ez az osztály információk gyűjtésére szolgál egy adott hozzáférés-módosítóval kapcsolatban.
A java.lang.Class alkalmazásában alkalmazott módszerek
- Public String getName () : Visszaadja az osztály nevét.
- public Class getSuperclass () : Visszaadja a szuper osztály referenciát
- Public Class [] getInterfaces () : A megadott osztály által megvalósított interfészek tömbjét adja eredményül
- Nyilvános a getModifiers () -ben: A megadott osztály módosítóit reprezentáló egész értéket ad vissza, amelyet paraméterként kell átadni a " public static String toString (int i)" módszerhez, amely az adott osztály hozzáférési specifikátorát adja vissza.
Hogyan lehet teljes körű információt szerezni egy osztályról
Ahhoz, hogy információt szerezzünk egy osztály változóiról, módszereiről és konstruktorairól, létre kell hoznunk az osztály objektumát.public class Guru99ClassObjectCreation {public static void main (String[] args) throws ClassNotFoundException {//1 - By using Class.forname() methodClass c1 = Class.forName("Guru99ClassObjectCreation");//2- By using getClass() methodGuru99ClassObjectCreation guru99Obj = new Guru99ClassObjectCreation();Class c2 = guru99Obj.getClass();//3- By using .classClass c3= Guru99ClassObjectCreation.class;}}
1. példa: Hogyan lehet megszerezni az osztály metaadatait
A következő példa bemutatja, hogyan szerezhetünk metaadatokat, például: Osztálynév, szuper osztálynév, megvalósított interfészek és egy osztály hozzáférési módosítói.
Megkapjuk az alábbi Guru99Base.class nevű osztály metaadatait:
import java.io.Serializable;public abstract class Guru99Base implements Serializable,Cloneable {}
- Az osztály neve: Guru99Base
- Hozzáférés-módosítói: nyilvánosak és elvontak
- Interfészeket valósított meg: Serializálható és Klónozható
- Mivel egyetlen osztályt sem terjesztett ki kifejezetten, a szuper osztály a következő: java.lang.Object
import java.lang.reflect.Modifier;public class Guru99GetclassMetaData {public static void main (String [] args) throws ClassNotFoundException {// Create Class object for Guru99Base.classClass guru99ClassObj = Guru99Base.class;// Print name of the classsystem.out.println("Name of the class is : " +guru99ClassObj.getName());// Print Super class namesystem.out.println("Name of the super class is : " +guru99ClassObj.getSuperclass().getName());// Get the list of implemented interfaces in the form of Class array using getInterface() methodclass[] guru99InterfaceList = guru99classObj.getInterfaces();// Print the implemented interfaces using foreach loopsystem.out.print("Implemented interfaces are : ");for (Class guru99class1 : quru99 InterfaceList) {system.out.print guru99class1.getName() + " ");}system.out.println();//Get access modifiers using get Modifiers() method and toString() method of java.lang.reflect.Modifier classint guru99AccessModifier= guru99classObj.getModifiers();// Print the access modifiersSystem.Out.println("Access modifiers of the class are : " +Modifier.tostring(guru99AccessModifier));}}
- nyomtassa ki az osztály nevét a getName módszerrel
- Nyomtassa ki a szuper osztály nevét a getSuperClass (). GetName () módszerrel
- Nyomtassa ki a megvalósított interfészek nevét
- Nyomtassa ki az osztály által használt hozzáférés-módosítókat
2. példa: A változó metaadatainak megszerzése
A következő példák bemutatják, hogyan lehet lekérni a változó metaadatait:
Itt egy Guru99VariableMetaData .class nevű osztályt hozunk létre néhány változóval:
package guru;public class Guru99VariableMetaData {public static int guru99IntVar1=1111;static int guru99IntVar2=2222;static String guru99StringVar1="guru99.com";static String guru99StringVar2="Learning Reflection API";} Lépések a fenti osztályban szereplő változók metaadatainak megszerzéséhez:
- Hozza létre a fenti osztály osztályobjektumát, azaz a Guru99VariableMetaData.class az alábbiak szerint:
Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();Class guru99ClassObjVar = guru99ClassVar.getClass();
- Szerezze meg a metaadatokat mezőtömb formájában a getFields () vagy a getDeclaredFields () módszerekkel, az alábbiak szerint:
Field[] guru99Field1= guru99ClassObjVar .getFields();Field[] guru99Fiel2= guru99ClassObjVar .getDeclaredFields();
A getFields () metódus a nyilvános változó metaadatait adja vissza a megadott osztályból, valamint annak szuperosztályából.
A getDeclaredFields () metódus csak a megadott osztály összes változójának metaadatait adja vissza.
- Szerezd meg a változók nevét a "public String getName ()" módszerrel.
- Szerezze be a változók adattípusát a "public class getType ()" módszerrel.
- Szerezzük meg a változó értékét a "public xxx get (Field)" módszerrel.
Itt xxx lehet bájt vagy rövid bármilyen típusú értékhez, amelyet be akarunk szerezni.
- Szerezze be a változók hozzáférés-módosítóit a getModifier () és a Modifier.toString (int i) módszerekkel.
Itt írunk egy osztályt, hogy megkapjuk a Guru99VariableMetaData .class osztályban jelenlévő változók metaadatait:
package guru;import java.lang.reflect.Field;public class Guru99VariableMetaDataTest {public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {// Create Class object for Guru99VariableMetaData.classGuru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();Class guru99ClassObjVar = guru99ClassVar.getClass();// Get the metadata of all the fields of the class Guru99VariableMetaDataField[] guru99Field1= guru99ClassObjVar.getDeclaredFields();// Print name, datatypes, access modifiers and values of the varibales of the specified classfor(Field field : guru99Field1) {System.out.println("Variable name : "+field.getName());System.out.println("Datatypes of the variable :"+field.getType());int guru99AccessModifiers = field.getModifiers();System.out.printlln("Access Modifiers of the variable : "+Modifier.toString(guru99AccessModifiers));System.out.println("Value of the variable : "+field.get(guru99ClassVar));System.out.println();system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ;}}} - Létrehozott osztályobjektum a Guru99VariableMetaData.class számára
- Megvan a változók összes metaadata egy Field tömbben
- Kinyomtatta az összes változó nevét a Guru99VariableMetaData.class osztályban
- Kinyomtatta a Guru99VariableMetaData.class osztályban szereplő változók összes adattípusát
- Kinyomtatta a Guru99VariableMetaData.class osztályban szereplő változók összes hozzáférési módosítóját
- Az összes változó kinyomtatott értékei a Guru99VariableMetaData.class osztályban található változók összes adattípusának kinyomtatásában
- Hozza létre a fenti osztály osztályobjektumát, azaz a Guru99MethodMetaData.class az alábbiak szerint:
Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData ();Class guru99ClassObjVar = guru99ClassVar.getClass();
- Szerezzen metódusinformációt a Method tömbből a getMethods () és a getDeclaredMethods () módszerrel az alábbiak szerint:
Method[] guru99 Method 1= guru99ClassObjVar .get Methods();Method [] guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
A getMethods () metódus a nyilvános módszerek metaadatait adja vissza a megadott osztályból, valamint annak szuperosztályából.
A getDeclaredMethods () metódus csak a megadott osztály összes metódusát adja vissza.
- Szerezze be a metódus nevét a getName () metódussal.
- Szerezze be a metódus visszatérési típusát a getReturnType () módszerrel.
- A getModifiers () és a Modifiers.toString (int i) metódusok segítségével szerezzen be metódusok hozzáférés-módosítókat .
- A metódus paramétertípusainak lekérése a getParameterTypes () metódussal, amely egy osztály tömböt ad vissza.
- Kapd el a kivételt a getExceptionTypes () metódussal, amely egy osztály tömböt ad vissza.
- Létrehozott osztályobjektum a Guru99MethodMetaData.class számára
- Megvan az összes metaadat a metódus tömbben
- Kinyomtatta a Guru99MethodMetaData.class osztályban található összes metódusnevet
- A Guru99MethodMetaData.class osztály metódusainak nyomtatott visszatérési típusai
- Kinyomtatta a Guru99MethodMetaData.class osztály metódusainak összes hozzáférés-módosítóját
- A módszerek nyomtatott paramétertípusai a Guru99MethodMetaData.class fájlban
- A kinyomtatott kivételeket a Guru99MethodMetaData.class metódusok vetik el
- Létrehozott osztályobjektum a Guru99Constructor.class fájlhoz
- Megvan az összes konstruktor összes metaadata a Constructor tömbben
- Kinyomtatta a Guru99Constructor.class osztályban szereplő összes kivitelező nevét
- Kinyomtatta a kivitelezők összes hozzáférési módosítóját a Guru99Constructor.class osztályban
- A konstruktorok nyomtatott paramétertípusai a Guru99Constructor.class fájlban
- A kinyomtatott kivételeket a kivitelezők a Guru99Constructor.class fájlba dobják
- A java reflexiós programozása segít lekérdezni és módosítani az osztályokról és az osztálytagokról szóló információkat, például a változót, a módszereket, a konstruktorokat.
- A Java tükröző API-ja a java.lang.reflect csomag osztályai és a java.lang.Class osztály módszerei segítségével valósítható meg.
- Néhány java.lang.Class osztály általánosan használt módszere a getName (), getSuperclass (), getInterfaces (), getModifiers () stb.
- A java.lang.reflect csomagban néhány általánosan használt osztály a Field, Method, Constructor, Modifier stb.
- A Reflection API hozzáférhet egy osztály privát módszereihez és változóihoz, amelyek biztonsági fenyegetést jelenthetnek.
- A Reflection API egy erőteljes képesség, amelyet a Java nyújt, de bizonyos általános költségekkel jár, mint például a lassabb teljesítmény, a biztonsági rés és az engedélyek. Ezért a reflexió API-t a művelet végrehajtásának utolsó lehetőségeként kell kezelni.
3. példa: A módszer metaadatainak megszerzése
A következő példák bemutatják, hogyan lehet lekérni egy módszer metaadatait:
Itt létrehozunk egy Guru99MethodMetaData .class nevű osztályt néhány módszerrel
package guru;import java.sql.SQLException;public class Guru99MethodMetaData {public void guru99Add(int firstElement, int secondElement , String result)throws ClassNotFoundException, ClassCastException{System.out.println("Demo method for Reflextion API");}public String guru99Search(String searchString)throws ArithmeticException, InterruptedException{System.out.println("Demo method for Reflection API");return null;}public void guru99Delete(String deleteString)throws SQLException{System.out.println("Demo method for Reflection API");}}
Lépések a fenti osztály metódusainak megszerzéséhez:
Itt írunk egy osztályt, hogy megkapjuk a Guru99MethodMetaData.class osztályban jelenlévő módszerek metaadatait:
package guru;import java.lang.reflect.Method;import java.lang.reflect.Modifier;public class Guru99MethodMetaDataTest {public static void main (String[] args) {// Create Class object for Guru99Method MetaData.classclass guru99ClassObj = Guru99MethodMetaData.class;// Get the metadata or information of all the methods of the class using getDeclaredMethods()Method[] guru99Methods=guru99classObj.getDeclaredMethods();for(Method method : guru99Methods) {// Print the method namesSystem.out.println("Name of the method : "+method.getName());// Print return type of the methodsSystem.out.println("Return type of the method : "+method.getReturnType());//Get the access modifier list and printint guru99ModifierList = method.getModifiers();System.Out.printlin ("Method access modifiers : "+Modifier.toString(guru99ModifierList));// Get and print parameters of the methodsClass[] guru99ParamList= method.getParameterTypes();system.out.print ("Method parameter types : ");for (Class class1 : guru99ParamList){System.out.println(class1.getName()+" ");}System.out.println();// Get and print exception thrown by the methodClass[] guru99ExceptionList = method. getExceptionTypes();system.out.print("Excpetion thrown by method :");for (Class class1 : guru99ExceptionList) {System.out.println (class1.getName() +" "):}System.Out.println();system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");}}}
4. példa: Hogyan lehet megszerezni a kivitelezők metaadatait
A következő példák bemutatják, hogyan lehet megszerezni a konstruktorok metaadatait:
Itt létrehozunk egy Guru99Constructor.class nevű osztályt különböző konstruktorokkal:
package guru;import java.rmi.RemoteException;import java.sql.SQLException;public class Guru99Constructor {public Guru99Constructor(int no) throws ClassCastException ,ArithmeticException{ }public Guru99Constructor(int no, String name) throws RemoteException ,SQLException{ }public Guru99Constructor(int no, String name, String address) throws InterruptedException{ }}
Itt írunk egy osztályt, hogy megkapjuk a Guru99Constructor.class osztályban jelen lévő konstruktorok metaadatait:
package guru;import java.lang.reflect.Constructor;public class Guru99ConstructorMetaDataTest {public static void main (String[] args) {// Create Class object for Guru99Constructor.classClass guru99Class=Guru99Constructor.class;// Get all the constructor information in the Constructor arrayConstructor[] guru99ConstructorList = guru99Class.getConstructors();for (Constructor constructor : guru99ConstructorList) {// Print all name of each constructorSystem.out.println("Constrcutor name : "+constructor.getName());//Get and print access modifiers of each constructorint guru99Modifiers= constructor.getModifiers();System.Out.printlin ("Constrctor modifier : "+Modifier.toString(guru99Modifiers));// Get and print parameter typesClass[] guru99ParamList=constructor.getParameterTypes();System.out.print ("Constrctor parameter types :");for (Class class1 : guru99ParamList) {System.out.println(class1.getName() +" ");}System. out.println();// Get and print exception thrown by constructorsClass[] guru99ExceptionList=constructor.getFxceptionTypes();System.out.println("Exception thrown by constructors :");for (Class class1 : guru99ExceptionList) {System.out.println(class1.getName() +" ");}System.out.println();System.out.println("*******************************************");}}}
Összegzés: