SYSTEM
获取元素
src/content/notes/system/获取元素.md 获取元素
获取类
反射技术的第一步是先得到 Class 类对象,有三种方式获取:
- 类名.class
- 类的对象.getClass()
- Class.forName(“类的全限名”):
public static Class<?> forName(String className)
Class 类下的方法:
| 方法 | 作用 |
|---|---|
| String getSimpleName() | 获得类名字符串:类名 |
| String getName() | 获得类全名:包名+类名 |
| T newInstance() | 创建 Class 对象关联类的对象,底层是调用无参数构造器,已经被淘汰 |
public class ReflectDemo{
public static void main(String[] args) throws Exception {
// 反射的第一步永远是先得到类的Class文件对象: 字节码文件。
// 1.类名.class
Class c1 = Student.class;
System.out.println(c1);//class _03反射_获取Class类对象.Student
// 2.对象.getClass()
Student swk = new Student();
Class c2 = swk.getClass();
System.out.println(c2);
// 3.Class.forName("类的全限名")
// 直接去加载该类的class文件。
Class c3 = Class.forName("_03反射_获取Class类对象.Student");
System.out.println(c3);
System.out.println(c1.getSimpleName()); // 获取类名本身(简名)Student
System.out.println(c1.getName()); //获取类的全限名_03反射_获取Class类对象.Student
}
}
class Student{}
获取构造
获取构造器的 API:
- Constructor getConstructor(Class… parameterTypes):根据参数匹配获取某个构造器,只能拿 public 修饰的构造器
- Constructor getDeclaredConstructor(Class… parameterTypes):根据参数匹配获取某个构造器,只要申明就可以定位,不关心权限修饰符
- Constructor[] getConstructors():获取所有的构造器,只能拿 public 修饰的构造器
- Constructor[] getDeclaredConstructors():获取所有构造器,只要申明就可以定位,不关心权限修饰符
Constructor 的常用 API:
| 方法 | 作用 |
|---|---|
| T newInstance(Object… initargs) | 创建对象,注入构造器需要的数据 |
| void setAccessible(true) | 修改访问权限,true 攻破权限(暴力反射) |
| String getName() | 以字符串形式返回此构造函数的名称 |
| int getParameterCount() | 返回参数数量 |
| Class<?>[] getParameterTypes | 返回参数类型数组 |
public class TestStudent01 {
@Test
public void getDeclaredConstructors(){
// a.反射第一步先得到Class类对象
Class c = Student.class ;
// b.定位全部构造器,只要申明了就可以拿到
Constructor[] cons = c.getDeclaredConstructors();
// c.遍历这些构造器
for (Constructor con : cons) {
System.out.println(con.getName()+"->"+con.getParameterCount());
}
}
@Test
public void getDeclaredConstructor() throws Exception {
// a.反射第一步先得到Class类对象
Class c = Student.class ;
// b.定位某个构造器,根据参数匹配,只要申明了就可以获取
//Constructor con = c.getDeclaredConstructor(); // 可以拿到!定位无参数构造器!
Constructor con = c.getDeclaredConstructor(String.class, int.class); //有参数的!!
// c.构造器名称和参数
System.out.println(con.getName()+"->"+con.getParameterCount());
}
}
public class Student {
private String name ;
private int age ;
private Student(){
System.out.println("无参数构造器被执行~~~~");
}
public Student(String name, int age) {
System.out.println("有参数构造器被执行~~~~");
this.name = name;
this.age = age;
}
}
//测试方法
public class TestStudent02 {
// 1.调用无参数构造器得到一个类的对象返回。
@Test
public void createObj01() throws Exception {
// a.反射第一步是先得到Class类对象
Class c = Student.class ;
// b.定位无参数构造器对象
Constructor constructor = c.getDeclaredConstructor();
// c.暴力打开私有构造器的访问权限
constructor.setAccessible(true);
// d.通过无参数构造器初始化对象返回
Student swk = (Student) constructor.newInstance(); // 最终还是调用无参数构造器的!
System.out.println(swk);//Student{name='null', age=0}
}
// 2.调用有参数构造器得到一个类的对象返回。
@Test
public void createObj02() throws Exception {
// a.反射第一步是先得到Class类对象
Class c = Student.class ;
// b.定位有参数构造器对象
Constructor constructor = c.getDeclaredConstructor(String.class , int.class);
// c.通过无参数构造器初始化对象返回
Student swk = (Student) constructor.newInstance("孙悟空",500); // 最终还是调用有参数构造器的!
System.out.println(swk);//Student{name='孙悟空', age=500}
}
}
获取变量
获取 Field 成员变量 API:
- Field getField(String name):根据成员变量名获得对应 Field 对象,只能获得 public 修饰
- Field getDeclaredField(String name):根据成员变量名获得对应 Field 对象,所有申明的变量
- Field[] getFields():获得所有的成员变量对应的 Field 对象,只能获得 public 的
- Field[] getDeclaredFields():获得所有的成员变量对应的 Field 对象,只要申明了就可以得到
Field 的方法:给成员变量赋值和取值
| 方法 | 作用 |
|---|---|
| void set(Object obj, Object value) | 给对象注入某个成员变量数据,obj 是对象,value 是值 |
| Object get(Object obj) | 获取指定对象的成员变量的值,obj 是对象,没有对象为 null |
| void setAccessible(true) | 暴力反射,设置为可以直接访问私有类型的属性 |
| Class getType() | 获取属性的类型,返回 Class 对象 |
| String getName() | 获取属性的名称 |
public class FieldDemo {
//获取全部成员变量
@Test
public void getDeclaredFields(){
// a.先获取class类对象
Class c = Dog.class;
// b.获取全部申明的成员变量对象
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName()+"->"+field.getType());
}
}
//获取某个成员变量
@Test
public void getDeclaredField() throws Exception {
// a.先获取class类对象
Class c = Dog.class;
// b.定位某个成员变量对象 :根据名称定位!!
Field ageF = c.getDeclaredField("age");
System.out.println(ageF.getName()+"->"+ageF.getType());
}
}
public class Dog {
private String name;
private int age ;
private String color ;
public static String school;
public static final String SCHOOL_1 = "宠物学校";
public Dog() {
}
public Dog(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
}
//测试方法
public class FieldDemo02 {
@Test
public void setField() throws Exception {
// a.反射的第一步获取Class类对象
Class c = Dog.class ;
// b.定位name成员变量
Field name = c.getDeclaredField("name");
// c.为这个成员变量赋值!
Dog d = new Dog();
name.setAccessible(true);
name.set(d,"泰迪");
System.out.println(d);//Dog{name='泰迪', age=0, color='null'}
// d.获取成员变量的值
String value = name.get(d)+"";
System.out.println(value);//泰迪
}
}
获取方法
获取 Method 方法 API:
- Method getMethod(String name,Class…args):根据方法名和参数类型获得方法对象,public 修饰
- Method getDeclaredMethod(String name,Class…args):根据方法名和参数类型获得方法对象,包括 private
- Method[] getMethods():获得类中的所有成员方法对象返回数组,只能获得 public 修饰且包含父类的
- Method[] getDeclaredMethods():获得类中的所有成员方法对象,返回数组,只获得本类申明的方法
Method 常用 API:
- public Object invoke(Object obj, Object… args):使用指定的参数调用由此方法对象,obj 对象名
public class MethodDemo{
//获得类中的所有成员方法对象
@Test
public void getDeclaredMethods(){
// a.先获取class类对象
Class c = Dog.class ;
// b.获取全部申明的方法!
Method[] methods = c.getDeclaredMethods();
// c.遍历这些方法
for (Method method : methods) {
System.out.println(method.getName()+"->"
+ method.getParameterCount()+"->" + method.getReturnType());
}
}
@Test
public void getDeclardMethod() throws Exception {
Class c = Dog.class;
Method run = c.getDeclaredMethod("run");
// c.触发方法执行!
Dog d = new Dog();
Object o = run.invoke(d);
System.out.println(o);// 如果方法没有返回值,结果是null
//参数一:方法名称 参数二:方法的参数个数和类型(可变参数!)
Method eat = c.getDeclaredMethod("eat",String.class);
eat.setAccessible(true); // 暴力反射!
//参数一:被触发方法所在的对象 参数二:方法需要的入参值
Object o1 = eat.invoke(d,"肉");
System.out.println(o1);// 如果方法没有返回值,结果是null
}
}
public class Dog {
private String name ;
public Dog(){
}
public void run(){System.out.println("狗跑的贼快~~");}
private void eat(){System.out.println("狗吃骨头");}
private void eat(String name){System.out.println("狗吃"+name);}
public static void inAddr(){System.out.println("在吉山区有一只单身狗!");}
}
暴力攻击
泛型只能工作在编译阶段,运行阶段泛型就消失了,反射工作在运行时阶段
- 反射可以破坏面向对象的封装性(暴力反射)
- 同时可以破坏泛型的约束性
public class ReflectDemo {
public static void main(String[] args) throws Exception {
List<Double> scores = new ArrayList<>();
scores.add(99.3);
scores.add(199.3);
scores.add(89.5);
// 拓展:通过反射暴力的注入一个其他类型的数据进去。
// a.先得到集合对象的Class文件对象
Class c = scores.getClass();
// b.从ArrayList的Class对象中定位add方法
Method add = c.getDeclaredMethod("add", Object.class);
// c.触发scores集合对象中的add执行(运行阶段,泛型不能约束了)
add.invoke(scores, "字符串");
System.out.println(scores);
}
}