Zusammenfassende Analyse basierend auf Reflexion in Java

Klassentest {

}

Demo der öffentlichen Klasse {
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.getClass());
System.out.println(t.getClass().getName());
}
}

}

Demo der öffentlichen Klasse {
public static void main(String[] args) {
//Methode 1:
Test t = new Test();
Class<? erweitert Test> c1 = t.getClass();
System.out.println(c1);

//Methode 2:
// Um ​​Spezifität zu vermeiden, wird hier nicht die Testklasse, sondern die String-Klasse in der Java-Bibliothek verwendet.
Class<String> c2 = String.class;
System.out.println(c2);

//Methode 3:
Die Methode //forName() löst eine Ausnahme aus
Klasse<?> c3 = null;
versuchen {
c3 = Class.forName("Test");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(c3);
}
}

//Erzeuge einen Verweis auf einen String
Zeichenfolge s = null;
versuchen {
//Das konstruierte Objekt in die String-Klasse umwandeln
Die Methode //newInstance() löst eine Ausnahme aus
s = (String) c.newInstance();
} Catch (InstantiationException e) {
e.printStackTrace();
} Catch (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println("String length: " + s.length());
}
}

Demo der öffentlichen Klasse {
// Die folgenden Methoden lösen zu viele Ausnahmen aus. Aus Gründen der Codekompaktheit werden sie hier direkt an die virtuelle Maschine geworfen.
public static void main(String[] args) löst eine Ausnahme aus {
Klasse<?> c = null;
versuchen {
c = Class.forName("java.lang.String");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
}
char[] ch = {'h','e','l','l','o'};
Zeichenfolge s = null;
//Den parametrisierten Konstruktor des Klassenobjekts abrufen. Die Parameter in den Klammern werden wie folgt geschrieben: type.class
Constructor<?> con = c.getConstructor(char[].class);
// Verwenden Sie diese Konstruktionsmethode, um ein neues String-Objekt zu erstellen. Der Parameter ist ein char-Array
s = (String) con.newInstance(ch);
System.out.println("Konstruierte Zeichenfolge: " + s);
}
}

Demo der öffentlichen Klasse {
// Die folgenden Methoden lösen zu viele Ausnahmen aus. Aus Gründen der Codekompaktheit werden sie hier direkt an die virtuelle Maschine geworfen.
public static void main(String[] args) löst eine Ausnahme aus {
Klasse<?> c = null;
versuchen {
c = Class.forName("java.lang.Boolean");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
}
//Die Methode getConstructors() gibt hier ein Konstruktor-Array zurück
Constructor<?>[] cons = c.getConstructors();
//Sie können die Druckmethode selbst schreiben. Der Einfachheit halber verwende ich Arrays.toString().
System.out.println(Arrays.toString(cons));
}
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
Klasse<?> c = null;
versuchen {
c = Class.forName("java.lang.Boolean");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
}
Klasse<?>[] in = c.getInterfaces();
System.out.println(Arrays.toString(in));
}
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
Klasse<?> c = null;
versuchen {
c = Class.forName("java.lang.Boolean");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
}
Methode[] m = c.getMethods();
//Okay, dieses Mal werde ich gnädig sein und eine Ausdruckliste schreiben.
for (int i = 0; i < m.length; i++) {
System.out.println(m[i]);
}
}
}

Klasse Person {
privater String-Name;
privates Int-Alter;
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
Klasse<?> c = null;
versuchen {
c = Class.forName("Person");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
}
Field[] f = c.getDeclaredFields();
for (int i = 0; i < f.length; i++) {
System.out.println(f[i]);
}
}
}

Klasse Person {
öffentlicher String-Name;
privates Int-Alter;

öffentliche Person(String name, int age) {
this.name = Name;
this.age = Alter;
}
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
Person p = neue Person("zhangsan",12);

Klasse<?> c = p.getClass();

//Den Wert des öffentlichen Attributs abrufen
Feld f1 = c.getField("name");
//get(p) gibt an, welcher Objektwert erhalten werden soll
String str = (String) f1.get(p);
System.out.println("Name: " + str);

//Den Wert des privaten Attributs abrufen
Feld f2 = c.getDeclaredField("age");
//age ist eine private Eigenschaft, also setzen Sie die Sicherheitsüberprüfung auf true
f2.setAccessible(true);
int age = (int) f2.get(p);
System.out.println("Alter: " + Alter);
}
}

Klasse Person {
privater String-Name;

öffentliche Person(Stringname) {
this.name = Name;
}

öffentlicher String toString() {
return „Name:“ + this.name;
}
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
Person p = new Person("王二狗");
System.out.println(p);
Klasse<?> c = p.getClass();

//Definieren Sie die zu ändernden Eigenschaften
Feld f = c.getDeclaredField("name");
f.setAccessible(true);
//Eigenschaften ändern und das festzulegende Objekt und den Wert übergeben
f.set(p, „Zhang Erdan“);
System.out.println(p);
}
}

Klasse Person {
public void print(int i) {
System.out.println("Ich schreibe Zahlen: " + i);
}

public static void say(String str) {
System.out.println("Ich sage: " + str);
}
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
Person p = neue Person();
Klasse<?> c = p.getClass();

Die //getMethod()-Methode muss den Methodennamen und den Parametertyp übergeben
Methode m1 = c.getMethod("print", int.class);
//invoke() bedeutet Aufruf und muss Objekte und Parameter übergeben
m1.invoke(p, 10);

Methode m2 = c.getMethod("say", String.class);
// Die Null bedeutet hier, dass sie nicht vom Objekt aufgerufen wird, also eine statische Methode ist
m2.invoke(null, „deine Schwester“);
}
}

Demo der öffentlichen Klasse {
public static void main(String[] args) löst eine Ausnahme aus {
int[] arr = {1,2,3,4,5};
Class<?> c = arr.getClass().getComponentType();

System.out.println("Array-Typ: " + c.getName());
int len ​​​​= Array.getLength(arr);
System.out.println("Array-Länge: " + len);
System.out.print("Durchlaufen Sie das Array:");
for (int i = 0; i < len; i++) {
System.out.print(Array.get(arr, i) + " ");
}
System.out.println();
//Array ändern
System.out.println("Das erste Element vor der Änderung: " + Array.get(arr, 0));
Array.set(arr, 0, 3);
System.out.println("Das geänderte erste Element: " + Array.get(arr, 0));
}
}