文章目录
📖个人介绍
大家好我是：一颗松
认真分享技术，记录学习点滴
如果分享对你有用请支持我哦🍺
点赞：👍 留言：✍收藏：⭐️
个人格言： 想法落实的最佳时机就是现在！🏄
1 反射快速上手案例
public class ReflectionQuestion {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
// 创建properties对象
Properties properties = new Properties();
// 加载文件
properties.load(new FileReader("E:\\Codes\\myProject\\JiShiTongXun\\reflectionDemo\\re.properties"));
// 获取值
String classpaht = properties.getProperty("classpaht");
String method = properties.getProperty("method");
System.out.println(classpaht);
// 使用反射机制创建类
// ①加载类
Class aClass = Class.forName(classpaht);
// ②通过得到的aClass对象，可以得到加载的类（配置文件中的类）的实例
ReflectionDemo rfd = (ReflectionDemo) aClass.newInstance();
// ③得到方法的对象
Method method1 = aClass.getMethod(method);
// ④通过方法对象，调用方法
method1.invoke(rfd);
}
}
2 使用反射的步骤
第一步：载Class类，会返回一个Class类型的对象
//①加载Class类，会返回一个Class类型的对象
Class aClass = Class.forName("加载类全路径");
第二步：通过Class类对象，得到需要加载的类Dog类的对象实例
//①加载Class类，会返回一个Class类型的对象
Class aClass = Class.forName(classpahttset);
第三步：通过aClass得到加载类的Method对象
// ③通过aClass得到加载类（Dog）的Method对象
Method sayColor = aClass.getMethod("方法名");
第四步：通过Method对象，调用方法
//④通过Method对象，调用方法
sayColor.invoke(aClass);
3 反射详解：
反射相关的主要类：
（1） java.lang.Class：代表一个类，Class对象表示某个类加载后在堆中的对象
（2） java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法
（3） java.lang.reflect.Field:代表类的成员变量
（4） java.lang.reflect.Constructor：代表类的构造方法；
4 反射的优化
Method、Field、Constructor都有setAccessible()方法
setAccessible方法是为了启动和禁止访问安全检查的开关
参数为true，表示反射的对象在访问时取消检查，提高反射效率。参数为false时，表示执行访问检查。
// 优化反射
sayColor.setAccessible(true);
5 Class类特点梳理
（1）Class也是一个类，它的父类也是Object
（2）Class类对象不是new出来的，而是系统创建的
（3）对于某个类的Class对象，在内存中只能存在一份，因为类只加载一次；
（4）每个类的实例都会知道自己是由哪个Class类生成
（5）通过Class类对象可以得到一个类的完整结构；
（6）Class对象存放在堆上
（7）类的字节码二进制文件是存放在方法区的
6 Class类的常用方法
public class ClassDemo {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
Class aClass = Class.forName("com.zinksl.reflectionDemo.reflection01.Dog");
// 获取包名
String packgname = aClass.getPackage().getName();
System.out.println(packgname);
// 获取全类名
System.out.println(aClass.getName());
// 通过Class对象，创建需求类对象示例
Dog dog = (Dog)aClass.newInstance();
// 通过反射获取属性
Field color = aClass.getField("color");
String colors = (String) color.get(dog);
System.out.println(colors);
// 通过反射给属性设置值
color.set(dog,"黄色");
// 通过反射获取所有属性
Field[] fields = aClass.getFields();
}
}7 获取Class类的方式
7.1 在编译阶段获取Class类对象，通过Class.forName()方法
如果已知全类名，则可以通过forName（）方法获取
应用场景：用于配置文件，读取全类名，路径加载类
7.2 在类加载阶段可以通过，类名.class获取
应用场景：多用于参数传递，如：通过反射得到对于构造器对象；
7.3 在运行阶段可以通过，对象名.getClass()方法获取
7.4 通过类加载器获取Class对象
8 java中哪些类有Class对象
（1）成员内部类、静态内部类、局部内部类、匿名内部类
（2）Interface：接口
（3）数组
（4）枚举
（5）annotation：注解
（6）基本数据类型
（7）void
9 类加载
【反射是java实现动态语言的关键，也是通过反射实现动态加载的】
类加载可分为静态加载和动态加载
静态加载，在编译期就加载类，如果找不到就报错，依赖性比较强
动态加载，在运行时加载需要的类，如果运行时用不到该类，就算找不到也不报错，依赖性比较弱
10 通反射获取类的结构信息：
方法名 | 说明 |
getName
| 获取全类名
|
getSimpleName
| 获取简单类名
|
getFields
| 获取所有public修饰的属性，包括本类及父类
|
getDeclardeFields
| 获取本类所有属性
|
getMethods
| 获取所有public修饰的方法，包括本类及父类
|
getDeclardeMethods
| 获取本类所有方法
|
getConstructors
| 获取所有public修饰的构造器，包括本类
|
getDeclardeConstructors
| 获取本类所有构造器
|
getPackage
| 以Package形式返回包信息
|
getSuperClass
| 以Class形式返回父类信息
|
getInterfaces
| 以Class[]形式返回接口信息
|
getAnnotations
| 以Annotation[] 形式返回注解信息
|
代码演示
public class ReflectionTest {
public static void main(String[] args) {
}
@Test
public void api() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// getMethods 获取所有public修饰的方法，包括本类及父类
// getDeclardeMethods 获取本类所有方法
// getConstructors 获取所有public修饰的构造器，包括本类及父类
// getDeclardeConstructors 获取本类所有构造器
// getPackage 以Package形式返回包信息
// getSuperClass 以Class形式返回父类信息
// getInterfaces 以Class[]形式返回接口信息
// getAnnotations 以Annotation[] 形式返回注解信息
// 1首先得到对应的Class对象
Class<?> aClass = Class.forName("com.zinksl.reflectionDemo.reflectionTest.Person");
// 2 得到目标类对象
Person person = (Person) aClass.newInstance();
// getName 获取全类名
// getSimpleName 获取简单类名
String name = aClass.getName();
System.out.println("全类名："+name);
System.out.println("简单类名："+aClass.getSimpleName());
// getFields 获取所有public修饰的属性，包括本类及父类
// getDeclardeFields 获取本类所有属性
Field[] fields = aClass.getFields();
for (Field f:fields){
System.out.println("本类及父类的所有共有属性："+f.getName());
}
Field[] declaredFields = aClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类所有属性："+declaredField.getName());
}
}
}
class Person{
public String name;
public int age;
private String hoby;
public Person() {
}
public Person(String name, int age, String hoby) {
this.name = name;
this.age = age;
this.hoby = hoby;
}
public void sayHello(){
System.out.println("hello");
}
private void sayHi(){
System.out.println("hi");
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return hoby
*/
public String getHoby() {
return hoby;
}
/**
* 设置
* @param hoby
*/
public void setHoby(String hoby) {
this.hoby = hoby;
}
public String toString() {
return "Person{name = " + name + ", age = " + age + ", hoby = " + hoby + "}";
}
}11 java.lang.reflect.Field类
（1）getModifiers:以int形式返回修饰符
【说明：默认修饰符：0，public：1，private：2，
protected：4，static：8,final：16；public static：1+8】
（2）getType:以Class形式返回类型
（3）getName：返回方法名
12 java.lang.reflect.Method类
（1）getModifiers:以int形式返回修饰符
【说明：默认修饰符：0，public：1，private：2，
protected：4，static：8,final：16；public static：1+8】
（2）getReturnType:以Class形式返回类型
（3）getName：返回方法名
（4）getParameterType:以Class[] 返回参数类型数组
13 java.lang.reflect.Constructor类
（1）getModifiers:以int形式返回修饰符
【说明：默认修饰符：0，public：1，private：2，
protected：4，static：8,final：16；public static：1+8】
（4）getParameterType:以Class[] 返回参数类型数组
（3）getName：返回构造器名（全类名）
13 通过反射创建对象
（1） 调用类中被public修饰的无参构造
（2）调用类中指定的构造器
（3）Class类相关方法
①newInstance ：调用类中无参构造器，获取对应类对象
②getConstructor(Class…)：根据参数列表获取对应的构造器对象
③getDecalaredConstructor(Class…)：根据参数列表获取对应的构造器对象
（4）Constructor类相关方法
①setAccessible；爆破
②newInstance(Object…):调用构造器
代码示例：
public class ReflectGetObject {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
// 1 先获取Person类的Class对象
Class personClass = Class.forName("com.zinksl.reflectionDemo.reflectGetObject.Person");
// 2通过public无参构造器，创造实例
Object o = personClass.newInstance();
System.out.println(o);
// 3通过public有参构造器，创造实例
//①先得到构造器
Constructor constructor = personClass.getConstructor(String.class);
//②通过构造器创建实例
Object o1 = constructor.newInstance("马云");
System.out.println(o1);
// 4 通过私有构造器，创造实例
//先得到构造器
Constructor constructor1 = personClass.getDeclaredConstructor(String.class,int.class,String.class);
// 爆破
constructor1.setAccessible(true);//使用反射，创建私有化构造器，对象
Object o2 = constructor1.newInstance("大黄", 80, "溜圈");
System.out.println(o2);
}
}
class Person{
private String name ="码云";
private int age = 20;
public String hoby;
public Person() {
}
public Person(String name){
this.name = name;
}
private Person(String name, int age, String hoby) {
this.name = name;
this.age = age;
this.hoby = hoby;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return hoby
*/
public String getHoby() {
return hoby;
}
/**
* 设置
* @param hoby
*/
public void setHoby(String hoby) {
this.hoby = hoby;
}
public String toString() {
return "Person{name = " + name + ", age = " + age + ", hoby = " + hoby + "}";
}
}14 通过反射访问类中成员
（1） 根据属性名 获取Field对象
Field f = Class对象.getDeclaredField(属性名)；
（2）爆破 f.setAccessible(true); f是 Field的对象；
（3）访问
f.set(o,值)；o表示对象
syso(f.get(o)); o表示对象
（4）如果是静态属性，则set、get中的o属性，可以设置为null；
代码示例：
public class ReflectionGetShuxing {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException, IllegalAccessException, InvocationTargetException, InstantiationException {
//1获得Class类对象
Class<?> aClass = Class.forName("com.zinksl.reflectionDemo.reflectGetObject.Person2");
// 2创建对象
Object o = aClass.newInstance();
// 3 获取Field的对象
Field hoby = aClass.getField("hoby");
// 4 设置属性
hoby.set(o,"抽烟喝酒烫头");
System.out.println(o);
Field age = aClass.getDeclaredField("age");
age.setAccessible(true);
age.set(o,9999);
System.out.println(o);
}
}
class Person2{
private static String name ="码云";
private int age = 20;
public String hoby;
public Person2() {
}
public Person2(String name){
this.name = name;
}
private Person2(String name, int age, String hoby) {
this.name = name;
this.age = age;
this.hoby = hoby;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return hoby
*/
public String getHoby() {
return hoby;
}
/**
* 设置
* @param hoby
*/
public void setHoby(String hoby) {
this.hoby = hoby;
}
public String toString() {
return "Person{name = " + name + ", age = " + age + ", hoby = " + hoby + "}";
}
}
