# **反射相關使用和暴破** ## **通過反射創建對象** 1. **方式一：**調用類中的public修飾的無參構造器； 2. **方式二：**調用類中的指定構造器； 3. **Class類相關方法：** - newInstance()：調用類中的無參構造器，獲取對應類的對象； - getCo ...
反射相關使用和暴破
通過反射創建對象
- 方式一：調用類中的public修飾的無參構造器；
- 方式二：調用類中的指定構造器；
- Class類相關方法：
- newInstance()：調用類中的無參構造器，獲取對應類的對象；
- getConstructor(Class...clazz)：根據參數列表，獲取對應的public構造器對象；
- getDecalaredConstructor(Class...clazz)：根據參數列表，獲取對應的所有構造器對象；
- Constructor類相關方法：
- setAccessible()：暴破；
- newInstance(Object...obj)：調用構造器；
代碼演示：
package com.hspedu.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author: 86199
* @date: 2023/6/5 20:32
* @description: 演示通過反射機制創建實例
*/
public class ReflectCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//先獲取User類的Class對象
Class<?> userClass = Class.forName("com.hspedu.reflection.User");
//1. 通過public無參構造器構造實例
Object user = userClass.newInstance();
System.out.println("user = " + user);
//2. 通過public有參構造器構造實例
/*
此時 constructor 對象就是這個構造器
public User(String name){//public 的有參構造器
this.name = name;
}
*/
//先得到對應的構造器
Constructor<?> constructor = userClass.getConstructor(String.class);
//創建實例，傳入實參
Object user1 = constructor.newInstance("小花");
System.out.println("user1 = " + user1);
//3. 通過非public有參構造器構造實例
//先得到對應的private構造器
Constructor<?> declaredConstructor = userClass.getDeclaredConstructor(String.class, int.class);
//創建實例
declaredConstructor.setAccessible(true);//暴破【暴力破解】，使用反射可以訪問private構造器/方法/屬性，反射面前，都是紙老虎
Object user2 = declaredConstructor.newInstance("小黑", 20);
System.out.println("user2 = " + user2);
}
}
class User{//User類
//屬性
private String name = "大黃";
private int age = 10;
public User() {//無參構造器
}
public User(String name){//public 的有參構造器
this.name = name;
}
private User(String name, int age) {//private 有參構造器
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User [ age = " + age + ", name = " + name + " ]";
}
}
/*運行結果
user = User [ age = 10, name = 大黃 ]
user1 = User [ age = 10, name = 小花 ]
user2 = User [ age = 20, name = 小黑 ]
*/
通過反射訪問類中成員
訪問屬性
-
根據屬性名獲取Field對象
Field f = clazz對象.getDeclaredField(屬性名);//獲取所有Field f = clazz對象.getField(屬性名);//獲取公有 -
暴破：
f.setAccessible(true)//f 是Field -
訪問
f.set(o, 值) //o 表示本類的對象 System.out.println(f.get(o));//o 表示對象 -
註意：如果是靜態屬性，則set和get中的參數o，可以寫成null；
代碼演示：
package com.hspedu.reflection;
import java.lang.reflect.Field;
/**
* @author: 86199
* @date: 2023/6/5 21:37
* @description: 演示反射操作屬性
*/
public class ReflectAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
//得到Student類對應的Class對象
Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
//創建對象
Object o = stuClass.newInstance();//o 的運行類型就是Student
System.out.println(o.getClass());//class com.hspedu.reflection.Student
//1. 使用反射得到age屬性對象
Field age = stuClass.getField("age");//拿到公有的
age.set(o, 88);//通過反射操作屬性
System.out.println(o);
System.out.println(age.get(o));//返回age的值
//2. 使用反射操作name屬性
Field name = stuClass.getDeclaredField("name");
name.setAccessible(true);//對name進行暴破，可以操作私有屬性
//name.set(o, "大黑");
name.set(null, "大白");//因為name是static修飾的，所以這裡 o 也可以寫成 null
System.out.println(o);
System.out.println(name.get(o));//獲取屬性值
System.out.println(name.get(null));//只有靜態的才能這樣用
}
}
class Student{//類
public int age;
private static String name;
public Student() {
}
@Override
public String toString() {
return "Student [ " +
"age = " + age + " name = " + name +
']';
}
}
/* 運行結果
class com.hspedu.reflection.Student
Student [ age = 88 name = null]
88
Student [ age = 88 name = 大白]
大白
大白
*/
訪問方法
-
根據方法名和參數列表獲取Method方法對象：
Method m = clazz.getDeclaredMethod(方法名, XX.class);//得到本類的所有方法Method m = clazz.getMethod(方法名, XX.class);//得到本類的public方法 -
暴破：
m.setAccessible(true); -
訪問：
Object returnVal = m.invoke(o, 實參列表);//o就是本類的對象 -
註意：如果是靜態方法，則invoke的參數o，可以寫成null；
代碼演示：
package com.hspedu.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author: 86199
* @date: 2023/6/5 21:56
* @description: 演示通過反射調用方法
*/
public class ReflectAccessMethod {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, InvocationTargetException, NoSuchMethodException {
//獲取Boss類的Class對象
Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
//創建對象
Object o = bossCls.newInstance();
//1. 調用public 的 hi 方法
//得到hi方法對象
// Method hi = bossCls.getMethod("hi", String.class);//OK
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
hi.invoke(o, "大黃！");
//2. 調用private的say方法
//得到say方法對象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
//因為say方法私有，所以需要先暴破
say.setAccessible(true);
System.out.println(say.invoke(o, 20, "張三", '男'));
//3. 因為say方法是static，所以可以這樣調用
System.out.println(say.invoke(null, 18, "李四", '女'));
//返回值，在反射中如果方法有返回值統統返回Object，但是運行類型和方法定義的返回類型相同
//如果返回類型是void，返回null也是Object類型
Object reVal = say.invoke(null, 23, "王五", '男');
System.out.println("reVal的運行類型" + reVal.getClass());
}
}
class Boss{//類
public int age;
private static String name;
public Boss() {//構造器
}
private static String say(int n, String s, char c){//靜態方法
return n + " " + s + " " + c;
}
public void hi(String s){//普通方法
System.out.println("hi " + s);
}
}
/* 運行結果
hi 大黃！
20 張三 男
18 李四 女
reVal的運行類型class java.lang.String
*/
