Reflection, eine grundlegende Einführung in Java

Heute habe ich etwas über Antireflexion in den Java-Grundlagen gelernt. Nach meinem persönlichen Verständnis nach dem Studium ist Reflexion eine Reihe von Werkzeugen zur Erlangung von Klassen, Eigenschaften, Methoden usw. (Eigentlich fühlt es sich ein bisschen so an, als würde man nach dem Erlernen des Nachdenkens kaltes Wasser trinken, um meinen Durst zu löschen. Aber ich weiß wirklich nicht, wie es schmeckt. Vielleicht habe ich das Wesentliche nicht gelernt. Ich kann das Gefühl haben, dass etwas fehlt. Das hier Dies ist der letzte Teil, den ich gelernt habe. Ich möchte ihn noch einmal durchgehen und dann andere Dinge lernen professionell, und ich habe einige Denkfehler)

Bevor ich die Reflexion lernte, erinnerte ich mich zunächst an die variablen Parameter.

public static void main(String[] args) {
            test();//调用方法1test("JAVA");//调用方法2test("JAVA","工程师");//调用方法3test(new String[]{"水果","电器"});//调用方法4        }    static void test(String ... array){  //直接打印：System.out.println(array);for(String str:array){  //利用增强for遍历            System.out.println(str);
            }
        }

Der Grund, warum ich mich an variable Parameter erinnere, ist, dass es der Anwendung der Reflexion etwas ähnelt. Wenn eine Methode als variabler Parameter definiert ist, werden die Einschränkungen bei der Parameterübergabe beim Aufruf stark reduziert. Im Nachhinein verwenden wir einige Methoden, um das Instanzobjekt der Klasse abzurufen, und können dann einen Panoramablick auf die Methoden, Attribute usw. in der Klasse erhalten. Wie wir in der vorherigen Studie gelernt haben, werden Methoden, Eigenschaften usw. in statische und nicht statische, private und nicht private unterteilt. Wenn wir also anrufen, welches Stück möchten wir erhalten oder welches möchten wir nur? Gibt es einen Weg, dies zu erreichen? Zu diesem Zeitpunkt erschien eine Reflexion, und jetzt ist das alles, was ich darüber verstehe. weiter so.

1. Das Konzept der Reflexion

Der JAVA-Reflexionsmechanismus befindet sich im laufenden Zustand (beachten Sie, dass er sich nicht während der Kompilierung befindet). Diese Klasse Alle Eigenschaften und Methoden können für jedes Objekt aufgerufen werden. Diese dynamische Erfassung von Informationen und die Funktion des dynamischen Aufrufs der Methoden des Objekts werden als Reflexionsmechanismus der Java-Sprache bezeichnet.

Der Java-Reflektionsmechanismus bietet hauptsächlich die folgenden Funktionen:

--Bestimmen Sie die Klasse, zu der ein Objekt zur Laufzeit gehört.

--Konstruieren Sie zur Laufzeit eine beliebige Klasse.

-- Bestimmen Sie die Mitgliedsvariablen und Methoden einer beliebigen Klasse zur Laufzeit.

-- Rufen Sie die Methode eines beliebigen Objekts zur Laufzeit auf.

In JDK umfassen die mit der Reflexion verbundenen Klassen hauptsächlich die folgenden

//

Klassenklasse unter dem java.lang-Paket

Klassenklasse, die Instanzen darstellen Klassen und Schnittstellen in einer laufenden Java-Anwendung. Eine Aufzählung ist eine Klasse und eine Annotation ist eine Schnittstelle. Jedes Array gehört zu einer Klasse, die einem Klassenobjekt zugeordnet ist, das von allen Arrays mit demselben Elementtyp und derselben Dimension gemeinsam genutzt wird. Die grundlegenden Java-Typen (boolean, byte, char, short, int, long, float und double) und das Schlüsselwort void werden ebenfalls als Klassenobjekte dargestellt.

Über die Erklärung in der Klassenklasse JDK:

public finalclass Class<T> implements java.io.Serializable,
                              java.lang.reflect.GenericDeclaration,
                              java.lang.reflect.Type,
                              java.lang.reflect.AnnotatedElement {private static final int ANNOTATION= 0x00002000;private static final int ENUM      = 0x00004000;private static final int SYNTHETIC = 0x00001000;private static native void registerNatives();static {
        registerNatives();
    }/* * Constructor. Only the Java Virtual Machine creates Class
     * objects.     */private Class() {}

Einige Methoden in der Klassenklasse JDK (ich persönlich finde es sehr angenehm zu lesen, und ich möchte es aufnehmen)

public String toString() {return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))+ getName();
    }//应该是三元表达式

public static Class<?> forName(String className)throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)throws ClassNotFoundException
    {
        Class<?> caller = null;
        SecurityManager sm = System.getSecurityManager();if (sm != null) {// Reflective call to get caller class is only needed if a security manager// is present.  Avoid the overhead of making this call otherwise.caller = Reflection.getCallerClass();if (loader == null) {
                ClassLoader ccl = ClassLoader.getClassLoader(caller);if (ccl != null) {
                    sm.checkPermission(
                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
        }return forName0(name, initialize, loader, caller);
    }

private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)throws ClassNotFoundException;

public T newInstance()throws InstantiationException, IllegalAccessException
    {if (System.getSecurityManager() != null) {
            checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
        }// NOTE: the following code may not be strictly correct under// the current Java memory model.// Constructor lookupif (cachedConstructor == null) {if (this == Class.class) {throw new IllegalAccessException("Can not call newInstance() on the Class for java.lang.Class");
            }try {
                Class<?>[] empty = {};final Constructor<T> c = getConstructor0(empty, Member.DECLARED);// Disable accessibility checks on the constructor// since we have to do the security check here anyway// (the stack depth is wrong for the Constructor's// security check to work)                java.security.AccessController.doPrivileged(new java.security.PrivilegedAction<Void>() {public Void run() {
                                c.setAccessible(true);return null;
                            }
                        });
                cachedConstructor = c;
            } catch (NoSuchMethodException e) {throw new InstantiationException(getName());
            }
        }
        Constructor<T> tmpConstructor = cachedConstructor;// Security check (same as in java.lang.reflect.Constructor)int modifiers = tmpConstructor.getModifiers();if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();if (newInstanceCallerCache != caller) {
                Reflection.ensureMemberAccess(caller, this, null, modifiers);
                newInstanceCallerCache = caller;
            }
        }// Run constructortry {return tmpConstructor.newInstance((Object[])null);
        } catch (InvocationTargetException e) {
            Unsafe.getUnsafe().throwException(e.getTargetException());// Not reachedreturn null;
        }
    }

public String getName() {
        String name = this.name;if (name == null)this.name = name = getName0();return name;
    }

// cache the name to reduce the number of calls into the VMprivate transient String name;private native String getName0();

Es gibt noch viele weitere, daher werde ich sie vorerst nicht aufzeichnen. . . . .

//java.lang.reflect  包下
Constructor 代表构造函数
Method 代表方法
Field 代表字段
Array 与数组相关

2. Beschreibung der Klassenklasse

常用的得到Class类的方法 // Class c=new Class(); 不可以，因为它被私有化了1) Class c=Student.class;   //用类名.class 就可以得到Class类的实例2) Student stu=new Student();
Class c=stu.getClass();   //用对象名.getClass();3) Class c=Class.forName("com.mysql.jdbc.Driver");

//例一  通过调用无参的构造函数,创建类对象public class Test {public static void main(String[] args) throws InstantiationException, IllegalAccessException {
    Class clazz=Dog.class;
    Dog dog=(Dog)clazz.newInstance();
    dog.shout();
    }
}            
class Dog{void shout(){
    System.out.println("汪汪");
    }
}

Durch Beispiel 1 habe ich die Vorteile der Verwendung von Reflexion nicht erkannt, eh~~

//例二 上例的改写Class clazz=Class.forName("com.weiboo.Dog"); //注意,必须是类的全部Dog dog=(Dog)clazz.newInstance();
dog.shout();

//例三  (运行本类,Dog 和 Cat 类,必须有一个无参的构造函数)public class Test {public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    Dog dog=(Dog)createObj(Dog.class);
    dog.shout();
                
    Cat cat=(Cat)createObj(Cat.class);
    cat.speak();
    }                    
static Object createObj(Class clazz) throws InstantiationException, IllegalAccessException{return clazz.newInstance();  //调用的是newInstance() 方法创建的类对象,它调用的是类中无参的构造方法}
    }        
class Dog{void shout(){
    System.out.println("汪汪");
    }
}        
class  Cat{void speak(){
    System.out.println("喵~~~");        
    }
}

3 anderer Klassen

1) Konstruktor

stellt den Konstruktor in der Klasse dar. Die Class-Klasse stellt die folgenden vier Methoden bereit:

public Constructor[ ] getConstructors () //Gibt eine Sammlung aller öffentlichen Konstruktoren in der Klasse zurück. Der Standardkonstruktor-Index ist 0

public Constructor getConstructor(Class... parameterTypes) //Return Geben Sie die Öffentlichkeit an Konstruktor, und der Parameter ist der Konstruktorparametertypsatz

public Constructor< ;?>[] getDeclaredConstructors() //Gibt alle Konstruktoren in der Klasse zurück, einschließlich private

public Constructor< ;T> getDeclaredConstructor(Class... parameterTypes) // Einen beliebigen angegebenen Konstruktor zurückgeben, einschließlich privater

import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;//例子 得到某个类中指定的某个构造函数所对应的 Constructor对象class Test2 {public static void main(String[] args) throws InstantiationException,
            IllegalAccessException, ClassNotFoundException,
            NoSuchMethodException, SecurityException, IllegalArgumentException,
            InvocationTargetException {
        Class<Cat> clazz = Cat.class;

        Constructor<Cat> c = clazz.getConstructor(int.class, String.class);
        Cat cat = (Cat) c.newInstance(20, "加飞猫");
        cat.speak();
    }class Cat {private String name;private int age;public Cat(int age, String name) {this.age = age;this.name = name;
        }public Cat(String content) {
            System.out.println("这是构造函数得到的参数" + content);
        }void speak() {
            System.out.println("喵~~~");
            System.out.println("我的名字是" + this.name + "我的年龄是" + this.age);
        }
    }
}

/例子 访问类中的私有构造函数
Class clazz=Cat.class;
Constructor c=clazz.getDeclaredConstructor();
c.setAccessible(true);  //让私有成员可以对外访问Cat cat=(Cat) c.newInstance();  //对于私有的来说,能不能行?cat.speak();

2) Methode stellt die Methode in der Klasse dar

Die Class-Klasse stellt die folgenden vier Methoden bereit

public Method[] getMethods() //Alle öffentlichen Methoden abrufen Sammlung, einschließlich erweiterter geerbter

public Method getMethod(String name,Class... parameterTypes) // Den angegebenen öffentlichen Methodenparameter 1 abrufen: Methodenname Parameter 2: Parametertypsatz

public Method[] getDeclaredMethods () //Alle Methoden (einschließlich privater) abrufen, außer der geerbten

public Method getDeclaredMethod(String name,Class... parameterTypes) //Eine beliebige angegebene Methode abrufen, außer der geerbten

//调用类中的私有方法main 函数
Class  clazz=Cat.class;//调用一个不带参数的方法Method m=clazz.getDeclaredMethod("speak");
m.setAccessible(true);
Cat c=new Cat();
m.invoke(c);  //让方法执行                
                    
//调用一个带参数的方法Method m=clazz.getDeclaredMethod("eat", int.class,String.class);
m.setAccessible(true);
Cat c=new Cat();
m.invoke(c, 20,"鱼");    

class  Cat{private String name;private int age;
                        
Cat(){    
}public Cat(int age,String name){this.age=age;this. name=name;
    }                        
public Cat(String content){
    System.out.println("这是构造函数得到的参数"+content);
    }                        private void speak(){
    System.out.println("喵~~~");        
    System.out.println("我的名字是"+this.name+"我的年龄是"+this.age);
    }                        private void eat(int time,String something){
    System.out.println("我在"+time +"分钟内吃了一个"+something);
    }
}

3) Field 代表字段

public Field getDeclaredField(String name)  // 获取任意指定名字的成员

public Field[] getDeclaredFields()  // 获取所有的成员变量,除了继承来的

public Field getField(String name)  // 获取任意public成员变量,包含继承来的

public Field[] getFields() // 获取所有的public成员变量

//例子 访问字段public class Test {public static void main(String[] args) throws Exception {
    Class clazz=Cat.class;                         /* Field field= clazz.getField("home");
    Cat c=new Cat();
    Object obj=field.get(c);
    System.out.println(obj); // 家*/ 
    Cat cat=new Cat();
    Field  [] fieldList= clazz.getDeclaredFields();for(Field f:fieldList){  //访问所有字段f.setAccessible(true);
    System.out.println(f.get(cat)); 
                                   }
        }
}                            
class  Cat{private String name="黑猫";private int age=2;public String home="家";
}

四、反射的应用

用一个例子来说明一下，比较两个同类对象中的所有字段,不同的并把它输出来。

import java.lang.reflect.Field;import java.util.HashMap;import java.util.Map;public class Test {public static void main(String[] args) throws Exception {
        Student stu1 = new Student(24, "李磊", "工程大学", "女");
        Student stu2 = new Student(20, "王一", "师大", "男");
        Map<String, String> map = compare(stu1, stu2);for (Map.Entry<String, String> item : map.entrySet()) {
            System.out.println(item.getKey() + ":" + item.getValue());
        }
    }static Map<String, String> compare(Student stu1, Student stu2) {
        Map<String, String> resultMap = new HashMap<String, String>();

        Field[] fieldLis = stu1.getClass().getDeclaredFields(); // 得到stu1所有的字段对象try {for (Field f : fieldLis) {
                f.setAccessible(true); // 别忘了，让私有成员可以对外访问Object v1 = f.get(stu1);
                Object v2 = f.get(stu2);if (!(v1.equals(v2))) {
                    resultMap.put(f.getName(), "stu1的值是" + v1 + "   stu2的值是"
                            + v2);
                }
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        }return resultMap;

    }

}class Student {private String name;private String school;private String sex;public Student(int age, String name, String school, String sex) {this.age = age;this.name = name;this.school = school;this.sex = sex;
    }private int age;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 getSchool() {return school;
    }public void setSchool(String school) {this.school = school;
    }public String getSex() {return sex;
    }public void setSex(String sex) {this.sex = sex;
    }
}

Das obige ist der detaillierte Inhalt vonReflection, eine grundlegende Einführung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!