Guida all'uso del meccanismo di riflessione in Java e riassunto degli esempi

This article describes the usage of Java programming reflection mechanism. Share it with everyone for reference, as follows:

Introduction:Reflection: Dynamic acquisition of class (bytecode file such as Person.class in this article) and execute its members. Reflection is encountered less frequently in Android application layer development, but it is necessary to master and apply it proficiently for those who want to penetrate the bottom layer.

classe reale

Person.java

package com.sunwenou.reflect; // nome del pacchetto
public class Person {
  private String name;
  private int age;
  public Person() { // senza parametri
  }
  public Person(String name, int age) { // con parametri
    super();
    this.name = name;
    this.age = age;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  @Override
  public String toString() {
    return name+","+age;
  }
  public void show() { // senza parametri
    System.out.println("show");
  }
  public void fun(String ss) { // con parametri
    System.out.println(ss);
  }
  public static void function() { // static
    System.out.println("static");
  }
}

metodo per ottenere il file bytecode dinamicamente

In questo articolo, per rendere il post più conciso, si lancia generalmente Exception e si omette import, come di seguito.

package com.sunwenou.reflect;
public class Demo1 {
  /**
   * metodo per ottenere il file bytecode dinamicamente
   * 1: utilizza il metodo getClass() fornito dalla classe Object
   *  Questo metodo richiede un oggetto
   * 2: ogni tipo di dati ha una proprietà statica class, che restituisce l'oggetto del file bytecode di questo tipo di dati
   *  int.class  Person.class
   * 3: utilizza il metodo forName() fornito dalla classe Class
   *  È sufficiente fornire una stringa, che deve essere composta da nome del pacchetto+nome della classe
   */
  public static void main(String[] args) throws Exception {
    //getClaz();
    //getCalz2();
    getClaz3();
  }
  //utilizza il metodo forName() fornito dalla classe Class
  public static void getClaz3() throws Exception {
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Class<?> claz2 = Class.forName("com.sunwenou.reflect.Person");
    System.out.println(claz==claz2);
  }
  //每种数据类型都有一个静态的class属性
  public static void getCalz2() {
    Class<Person> p1 = Person.class;
    Class<Person> p2 = Person.class;
    System.out.println(p1==p2);
  }
  //使用Object类提供的 Class getClass()方法
  public static void getClaz() {
    Person person1 = new Person();
    Class<? extends Person> claz = person1.getClass();//Person.class
    Person person2 = new Person();
    Class<? extends Person> claz2 = person2.getClass();//Person.class
    System.out.println(claz==claz2);
  }
}

动态获取类，并创建对象

package com.sunwenou.reflect;
public class Demo2 {
  public static void main(String[] args) throws Exception {
    //createObj();
    createObj2();
  }
  public static void createObj2() throws Exception {
    //Person person = new Person("lisi",23);
    //Ottieni l'oggetto bytecode
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");//Person.class
    //得到带参数的构造方法所属的Constructor类型的对象
    Constructor constructor = claz.getConstructor(String.class,int.class);
    //使用Constructor类提供的创建对象的方法创建对象
    Person person = (Person)constructor.newInstance("lisi",23);
    System.out.println(person);
  }
  public static void createObj() throws Exception {
    //Person person = new Person();
    //Ottieni l'oggetto bytecode
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Object obj = claz.newInstance();//Crea l'oggetto utilizzando il costruttore con parametri vuoti
    System.out.println(obj);
  }
}

Ottieni la classe dinamicamente e assegna un valore al membro variabile

package com.sunwenou.reflect;
public class Demo3 {
  public static void main(String[] args) throws Exception {
    //Person p = new Person();
    //p.name = "lisi";
    //Ottieni l'oggetto bytecode
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    //Ottieni l'oggetto del tipo Field che appartiene al membro
    //Field field = claz.getField("name");//Ottieni è il membro con permessi public
    Field field = claz.getDeclaredField("name");//Ottieni tutti i campi dichiarati
    System.out.println(field);
    //I variabili di membro non statiche dipendono dall'oggetto
    Object obj = claz.newInstance();
    field.setAccessible(true);//Forza l'accesso, imposta come accessibile
    field.set(obj, "张三");
    System.out.println(obj);
  }
}

Ottieni la classe dinamicamente ed esegui il metodo

package com.sunwenou.reflect;
public class Demo4 {
  public static void main(String[] args) throws Exception {
    //method1();
    method2();
    method3();
  }
  public static void method3() throws Exception {
    //Ottieni l'oggetto bytecode
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Method m = claz.getMethod("function", null);
    m.invoke(null, null);
  }
  ////Esegui il metodo con parametri
  public static void method2() throws Exception {
    //Ottieni l'oggetto bytecode
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    Method m = claz.getMethod("fun", String.class);
    Object obj = claz.newInstance();
    m.invoke(obj, "hello");
  }
  //Esegui il metodo senza parametri
  public static void method1() throws Exception {
    //Person person = new Person(); person.show();
    //Ottieni l'oggetto bytecode
    Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
    //Ottieni l'oggetto bytecode del metodo eseguito
    Method m = claz.getMethod("show", null);
    //I metodi non statici sono dipendenti dall'oggetto
    Object obj = claz.newInstance();
    //Esegui il metodo
    m.invoke(obj, null);
  }
}

Questo è l'uso di base della reflection, possiamo creare oggetti attraverso il file bytecode dell'oggetto quando non possiamo creare oggetti normalmente, eseguire i metodi al suo interno, hai imparato??

Chi è interessato a ulteriori contenuti su Java può consultare le sezioni speciali del nostro sito: 'Guida di introduzione e avanzamento alla progettazione di programmi orientati agli oggetti Java', 'Guida alla struttura dei dati e agli algoritmi Java', 'Concetti di sommario delle tecniche di manipolazione dei nodi DOM Java', 'Riassunto delle tecniche di manipolazione dei file e delle directory Java' e 'Riassunto delle tecniche di manipolazione della cache Java'.

Spero che il contenuto di questo articolo possa essere utile per la progettazione di programmi Java.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il diritto d'autore è della proprietà del rispettivo autore, il contenuto è stato contribuito volontariamente dagli utenti di Internet e caricato autonomamente, il sito web non detiene il diritto di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, il sito web eliminerà immediatamente il contenuto sospetto di violazione del copyright.