Reflection, une introduction de base à Java
- 巴扎黑original
- 2017-07-20 13:09:481131parcourir
Aujourd'hui, j'ai découvert les bases de l'anti-reflet dans Java. Selon ma compréhension personnelle après mes études, la réflexion est un ensemble d'outils permettant d'obtenir des cours, des propriétés, des méthodes, etc. (En fait, après avoir appris à réfléchir, c'est un peu comme boire de l'eau froide pour étancher ma soif. Mais je ne réalise vraiment pas quel goût ça a. Peut-être que je n'ai pas appris l'essence. Je sens qu'il manque quelque chose. Ceci C'est ce que j'ai appris sur la base de Java. C'est la dernière partie, je veux la revoir, puis apprendre d'autres choses. Je veux aussi avoir le temps de lire des livres sur JVM et les systèmes informatiques. professionnel, et j'ai quelques lacunes dans la réflexion)
Avant d'apprendre la réflexion, j'ai d'abord rappelé les paramètres variables.
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);
}
}La raison pour laquelle je rappelle les paramètres variables est que cela ressemble quelque peu à l'application de la réflexion. Si une méthode est définie comme paramètre variable, les restrictions sur la transmission des paramètres lors de l'appel sont considérablement réduites. En réflexion, nous utilisons certaines méthodes pour obtenir l'objet instance de la classe, et nous pouvons ensuite avoir une vue panoramique des méthodes, attributs, etc. dans la classe. Comme nous l'avons appris dans l'étude précédente, les méthodes, propriétés, etc. sont divisées en statiques et non statiques, privées et non privées. Ainsi, lorsque nous appelons, quelle pièce voulons-nous obtenir, ou quelle pièce voulons-nous uniquement. obtenir ? Est-il possible de penser à un moyen d'y parvenir ? A ce moment-là, la réflexion est apparue, et maintenant c'est tout ce que j'en comprends. continuez comme ça.
1. Le concept de réflexion
Le mécanisme de réflexion JAVA est en cours d'exécution (notez qu'il ne l'est pas lors de la compilation). cette classe Toutes les propriétés et méthodes ; pour n'importe quel objet, n'importe laquelle de ses méthodes peut être appelée ; cette acquisition dynamique d'informations et la fonction d'appel dynamique des méthodes de l'objet sont appelées le mécanisme de réflexion du langage Java.
Le mécanisme de réflexion Java fournit principalement les fonctions suivantes :
--déterminer la classe à laquelle appartient tout objet au moment de l'exécution
--construire n'importe quelle classe au moment de l'exécution ;
-- déterminer les variables membres et les méthodes de n'importe quelle classe au moment de l'exécution ;
-- appeler la méthode de n'importe quel objet au moment de l'exécution
- - Générer des proxys dynamiques.
Dans JDK, les classes liées à la réflexion comprennent principalement les éléments suivants
//
Classe sous le package java.lang
Classe Les instances représentent classes et interfaces dans une application Java en cours d’exécution. Une énumération est une classe et une annotation est une interface. Chaque tableau appartient à une classe mappée à un objet Class, qui est partagé par tous les tableaux ayant le même type d'élément et la même dimension. Les types Java de base (boolean, byte, char, short, int, long, float et double) et le mot-clé void sont également représentés sous forme d'objets Class.
À propos de l'explication dans la classe Class 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() {}Quelques méthodes dans la classe Class JDK (je pense personnellement que c'est très confortable à lire, et je voulez l'enregistrer)
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();
Grâce à l'exemple 1, je n'ai pas vu les avantages de l'utilisation de la réflexion, hein~~
//java.lang.reflect 包下 Constructor 代表构造函数 Method 代表方法 Field 代表字段 Array 与数组相关
常用的得到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("汪汪");
}
}
//例二 上例的改写Class clazz=Class.forName("com.weiboo.Dog"); //注意,必须是类的全部Dog dog=(Dog)clazz.newInstance();
dog.shout();public Constructor//例三 (运行本类,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("喵~~~");
}
}
2) La méthode représente la méthode dans la classe
La classe Class fournit les quatre méthodes suivantesméthode publique[] getMethods() //Obtenir toutes les méthodes publiques Collection, y compris l'héritage étendu public Method getMethod(String name,Class... ParameterTypes) // Récupère le paramètre de méthode publique spécifié 1 : nom de la méthode, paramètre 2 : type de paramètre définiimport 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);
}
}
}public Method[] getDeclaredMethods () //Obtenir toutes les méthodes (y compris les méthodes privées), à l'exception de la /例子 访问类中的私有构造函数 Class clazz=Cat.class; Constructor c=clazz.getDeclaredConstructor(); c.setAccessible(true); //让私有成员可以对外访问Cat cat=(Cat) c.newInstance(); //对于私有的来说,能不能行?cat.speak();
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;
}
}
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!