目录
6、Fieldfi对象的获取Java把类中的属性抽象成了一个Field对象
1、什么是反射？
反射就是动态加载对象，并对对象进行剖析。 在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意一个方法， 这种动态获取 信息以及动态调用对象方法的功能成为 Java 反射机制。
2、反射的作用
1)在运行时判断任意一个对象所属的类 2)在运行时构造任意一个类的对象 3)在运行时判断任意一个类所具有的成员变量和方法 4)在运行时调用任意一个对象的方法
3、Class对象的获取
三种方式
类.class 对象.getClass() Class.forName()
package com.yhf.a_class;
import com.yhf.entity.User;
/**
* @Author yhf
* @Date 2024/8/29
* @Desc 200不是二百
*/
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException {
//1、类.class
Class<User> userClass = User.class;
//2、对象.getClass
Class<? extends User> aClass = new User().getClass();
//3、Class.forName("");
Class<?> aClass1 = Class.forName("com.yhf.entity.User");
}
}4、Constructor对象的获取
Java中把构造方法 抽象成了一个类对象叫Constructor
构造方法在类（Class对象）中，通过CLass对象来获取的！！！
1）Constructor<?>[] constructors = userClass.getConstructors();
2）Constructor<?>[] declaredConstructors = userClass.getDeclaredConstructors();
3）Constructor<User> constructor = userClass.getConstructor(null);
4）Constructor<User> constructor1 = userClass.getConstructor(String.class);
5）Constructor<User> constructor2 = userClass.getDeclaredConstructor(int.class);
import com.qf.entity.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @Author yhf
* @Date 2024/8/29
* @Desc 200不是二百
*/
public class Demo1 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//1.获取CLass对象
Class<User> userClass = User.class;
//2.通过Class对象获取构造方法（Constructor）对象
//getConstructors(): 获取非私有化的构造方法
Constructor<?>[] constructors = userClass.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
System.out.println("=======");
//getDeclaredConstructors() 获取全部的构造方法对象
Constructor<?>[] declaredConstructors = userClass.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
System.out.println("======");
//获取当个构造方法对象
//... 可以多个参数，用逗号隔开的！！
//parameterTypes 构造方法的参数的类型
//getConstructor(Class<?>... parameterTypes)
Constructor<User> constructor = userClass.getConstructor(null);
System.out.println(constructor);//获取无参的构造方法，因为 参数 null类型的
System.out.println("*******");
/**
* public User (String name) {
* this.name = name;
* }
*/
Constructor<User> constructor1 = userClass.getConstructor(String.class);
System.out.println(constructor1);
Constructor<User> constructor2 = userClass.getDeclaredConstructor(int.class);
System.out.println(constructor2);
//构造方法有啥用？一般借助于构造方法创建对象
//newInstance(Object ... initargs)
//initarg 构造方法中的参数进行赋值
User user = constructor.newInstance();
System.out.println(user);
User user1= constructor1.newInstance("狗蛋");
System.out.println(user1);
constructor2.setAccessible(true);//暴力反射
User user2 = constructor2.newInstance(12);
System.out.println(user2);
}
}
5、Method对象获取
Method对象 是把类中方法抽象成了Method对象
import com.qf.entity.User;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @Author yhf
* @Date 2024/8/29
* @Desc 200不是二百
*/
public class Demo1 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class<User> userClass = User.class;
//getMethods() 获取本类的非私有的方法和父类（Object）的方法
Method[] methods = userClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("============");
//getDeclaredMethods() 获取全部的方法，但是获取不了父类的方法
Method[] declaredMethods = userClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
System.out.println("----------------");
//获取单个方法
//getDeclaredMethod(String name, Class<?>... parameterTypes)
//Params:
//name – the name of the method
//parameterTypes – the parameter array
Method eat = userClass.getMethod("eat", null);//获取的是无参的eat方法
System.out.println(eat);
Method eat1 = userClass.getMethod("eat", String.class);//获取的是eat方法 带有一个参数 这个参数类型是String
System.out.println(eat1);
//获取私有的方法
Method sleep = userClass.getDeclaredMethod("sleep", null);
System.out.println(sleep);
//拿到方法对象干嘛？【重要】
//invoke(Object obj, Object... args)
//Params:
//obj – 是类对象 这个方法所在的对象
// args – 是方法的实参
User user = userClass.getConstructor(null).newInstance(null);
eat.invoke(user, null);
eat1.invoke(user, "xixi");
sleep.setAccessible(true);
sleep.invoke(user, null);
}
}
6、Fieldfi对象的获取Java把类中的属性抽象成了一个Field对象
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* @Author yhf
* @Date 2024/8/29
* @Desc 200不是二百
*/
public class Demo1 {
public static void main(String[] args) throws NoSuchFieldException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
/* Class<User> userClass = User.class;
Field[] fields = userClass.getFields();
for (Field field : fields) {
System.out.println(field); 打印了age
}*/
Class<Person> personClass = Person.class;
//表示公共字段的 Field对象的数组
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);//
}
System.out.println("====");
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//获取单个属性
Field name = personClass.getDeclaredField("name");
System.out.println(name);
Field age = personClass.getField("age");
Field sex = personClass.getDeclaredField("sex");
//获取到属性以后干嘛？ 属性可以赋值的
Person person = personClass.getConstructor(null).newInstance(null);
age.set(person, 18);
System.out.println(person);
sex.setAccessible(true);
sex.set(person, '男');
System.out.println(person);
}
}标签：反射,入门,System,Constructor,println,快速,class,userClass,out From： https://blog.csdn.net/hang_sa_mu/article/details/141686352