Summary analysis based on reflection in java

class Test {

}

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

}

public class Demo {
public static void main(String[] args) {
//Method 1:
Test t = new Test();
Class<? extends Test> c1 = t.getClass();
System.out.println(c1);

//Method 2:
//In order to avoid specificity, the Test class is not used here, but the String class in the java library is used.
Class<String> c2 = String.class;
System.out.println(c2);

//Method 3:
//forName() method will throw an exception
Class<?> c3 = null;
try {
c3 = Class.forName("Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(c3);
}
}

//Generate a reference to a string
String s = null;
try {
//Downcast the constructed object to the String class
//newInstance() method will throw exception
s = (String) c.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println("String length: " + s.length());
}
}

public class Demo {
//The following methods throw too many exceptions. For the sake of code compactness, they are thrown directly to the virtual machine here.
public static void main(String[] args) throws Exception {
Class<?> c = null;
try {
c = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
char[] ch = {'h','e','l','l','o'};
String s = null;
//Get the parameterized constructor of the Class object. The parameters in the brackets are written as: type.class
Constructor<?> con = c.getConstructor(char[].class);
//Use this construction method to construct a new string object, the parameter is a char array
s = (String) con.newInstance(ch);
System.out.println("Constructed string: " + s);
}
}

public class Demo {
//The following methods throw too many exceptions. For the sake of code compactness, they are thrown directly to the virtual machine here.
public static void main(String[] args) throws Exception {
Class<?> c = null;
try {
c = Class.forName("java.lang.Boolean");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//The getConstructors() method here returns a Constructor array
Constructor<?>[] cons = c.getConstructors();
//You can write the printing method yourself. For convenience, I use Arrays.toString() to make do.
System.out.println(Arrays.toString(cons));
}
}

public class Demo {
public static void main(String[] args) throws Exception {
Class<?> c = null;
try {
c = Class.forName("java.lang.Boolean");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?>[] in = c.getInterfaces();
System.out.println(Arrays.toString(in));
}
}

public class Demo {
public static void main(String[] args) throws Exception {
Class<?> c = null;
try {
c = Class.forName("java.lang.Boolean");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Method[] m = c.getMethods();
//Okay, this time I will be merciful and write a printout list.
for (int i = 0; i < m.length; i++) {
System.out.println(m[i]);
}
}
}

class Person {
private String name;
private int age;
}

public class Demo {
public static void main(String[] args) throws Exception {
Class<?> c = null;
try {
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]);
}
}
}

class Person {
public String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}
}

public class Demo {
public static void main(String[] args) throws Exception {
Person p = new Person("zhangsan",12);

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

//Get the value of the public attribute
Field f1 = c.getField("name");
//get(p) indicates which object value is to be obtained
String str = (String) f1.get(p);
System.out.println("Name: " + str);

//Get the value of the private attribute
Field f2 = c.getDeclaredField("age");
//age is a private property, so set the security check to true
f2.setAccessible(true);
int age = (int) f2.get(p);
System.out.println("Age: " + age);
}
}

class Person {
private String name;

public Person(String name) {
this.name = name;
}

public String toString() {
return "Name: " + this.name;
}
}

public class Demo {
public static void main(String[] args) throws Exception {
Person p = new Person("王二狗");
System.out.println(p);
Class<?> c = p.getClass();

//Define the properties to be modified
Field f = c.getDeclaredField("name");
f.setAccessible(true);
//Modify properties and pass in the object and value to be set
f.set(p, "Zhang Erdan");
System.out.println(p);
}
}

class Person {
public void print(int i) {
System.out.println("I am writing numbers: " + i);
}

public static void say(String str) {
System.out.println("I'm saying: " + str);
}
}

public class Demo {
public static void main(String[] args) throws Exception {
Person p = new Person();
Class<?> c = p.getClass();

//getMethod() method needs to pass in the method name and parameter type
Method m1 = c.getMethod("print", int.class);
//invoke() means calling and needs to pass in objects and parameters
m1.invoke(p, 10);

Method m2 = c.getMethod("say", String.class);
//The null here means not called by the object, that is, a static method
m2.invoke(null, "your sister");
}
}

public class Demo {
public static void main(String[] args) throws Exception {
int[] arr = {1,2,3,4,5};
Class<?> c = arr.getClass().getComponentType();

System.out.println("Array type: " + c.getName());
int len ​​= Array.getLength(arr);
System.out.println("Array length: " + len);
System.out.print("Traverse the array: ");
for (int i = 0; i < len; i++) {
System.out.print(Array.get(arr, i) + " ");
}
System.out.println();
//modify array
System.out.println("The first element before modification: " + Array.get(arr, 0));
Array.set(arr, 0, 3);
System.out.println("The modified first element: " + Array.get(arr, 0));
}
}