Java基础之反射笔记

在这里插入图片描述

Java基础之反射笔记

一、反射机制（reflection）

1、通过示例对反射机制快速了解

示例要求：根据配置文件re.properties 指定信息，创建Cat对象并调用方法hi：
配置文件re.properties：

classfullpath=com.yangh.Cat
method=hi

Cat类：

package com.yangh;

public class Cat {
    
    
    private String name = "招财猫";
    public void hi(){
    
    
        System.out.println("喵喵~~~~~");
    }
}

在ReflectionQuestion类中使用反射机制来创建Cat对象并调用方法hi：

package com.yangh.reflection.question;

import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectionQuestion {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //根据配置文件re.properties 指定信息，创建Cat对象并调用方法hi

/*
        //传统的方法 new 对象再调用方法
        Cat cat = new Cat();
        cat.hi();

*/

        //尝试用反射
        //1、使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.getProperty("classfullpath");
        String method = properties.getProperty("method");
//        System.out.println(classfullpath);

        //2、创建对象，使用反射机制
        //（1）加载类，返回Class类型的对象cls
        Class cls = Class.forName(classfullpath);
        //（2）通过对象cls得到加载的类com.yangh.Cat的对象实例
        Object o = cls.getDeclaredConstructor().newInstance();
        System.out.println(o.getClass());//允许类型
        //（3）通过cls得到加载的类com.yangh.Cat的method的方法对象
        //  即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(method);
        //（4）通过method1调用方法：即通过 方法对象 来实现调用方法
        method1.invoke(o);//传统方法： 对象.方法()   反射机制：方法.invoke(对象)
    }
}

2、反射机制基本介绍

反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息（比如成员变量、构造器、成员方法等），并且操作对象的属性及方法。反射在设计模式和框架底层都会用到。
加载完类之后，在堆中就产生了一个Class类型的对象（一个类只用一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称为”反射“。
反射原理图
Java反射机制可以完成：
1. 在运行时判断任意一个对象所属的类
2. 在运行时构造器任意一个类的对象
3. 在运行时得到任意一个类所具有的成员变量和方法
4. 在运行时调用任意一个对象的成员变量和方法
5. 生成动态代理
反射相关的主要类
1. java.lang.Class：代表一个类，Class对象表示某个类加载后在堆中的对象
2. java.lang.reflect.Method：代表类的方法，其对象实例表示某个类的方法
3. java.lang.reflect.Field：代表类的成员变量，其对象实例表示某个类的成员变量
4. java.lang.reflect.Constructor：代表类的构造方法，其对象实例表示构造方法
反射的优缺点：
1. 优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就是去底层支撑
2. 缺点：使用反射基本时解释执行，对执行速度又影响
反射调用优化
1. Method和Field、Constructor对象都有setAccessible()方法
2. setAccessible()方法作用是启动和禁用访问安全检查的开关
3. 参数值为true表示，反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查。

二、Class类

1、基本介绍

Class也是类，因此也继承Object对象
Class类对象不是new出来的，而是系统创建出来的
对于某个类的Class类对象，在内存中只有一份，因此类只加载一次
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类的完整结构，通过一系列API
Class对象放在堆中
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码、变量名、方法名、访问权限等等）

2、Class常用方法

Car类：

package com.yangh;

public class Car {
    
    
    public String brand = "baoma";
    public int price = 500000;
    public String color = "白色";

    @Override
    public String toString() {
    
    
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

package com.yangh.reflection.question;

import com.yangh.Car;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Class01 {
    
    

    private static Car car;

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    
    
        String classAllPath = "com.yangh.Car";
        //1、获取到Car类，对应的Class对象
        //<?>表示不确定的Java类型
        Class<?> aClass = Class.forName(classAllPath);
        //2、输出cls
        System.out.println(aClass);//显示aClass对象，是哪个类的Class对象，com.yangh.Car
        System.out.println(aClass.getClass());//输出aClass运行类型
        //3、得到包名
        System.out.println(aClass.getPackage().getName());
        //4、得到类名
        System.out.println(aClass.getName());
        //5、通过aClass创建对象实例
        car = (Car) aClass.getDeclaredConstructor().newInstance();
        System.out.println(car);
        //6、通过反射获得对象属性brand
        Field brand = aClass.getField("brand");
        System.out.println(brand.get(car));
        //7、通过反射给属性赋值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car));
        //8、得到所有的属性
        System.out.println("===========所有属性====");
        Field[] fields = aClass.getFields();
        for(Field f : fields){
    
    
            System.out.println(f.getName());
        }
    }
}

3、获取Class对象的六种方式（getClass）

1. 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取

例如：Class cls = Class.forName("java.lang.Cat");
应用场景：多用于配置文件，读取类全路径，加载类

2. 前提：若已知具体的类，通过类的class获取，该方法 最为安全可靠，程序性能最高

例如：Class cls = Cat.class;
应用场景：多用于参数传递比如通过反射得到对应构造器对象

3. 前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象

实例：Class clazz = 对象.getClass();
应用场景：通过创建好的对象，获取Class对象

4. 通过类加载器（类加载器有4种）来获取到类的Class对象
```
		//（1）先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //通过类加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass(classAllPath); 
```
5.  基本数据 （int，char，boolean，float，double，byte，long，short）按如下方式得到Class类对象：```Class cls = 基本数据类型.class```
6. 基本数据类型对应的包装类，可以通过```.type```得到Class类对象：```Class cls = 包装类.TYPE```

package com.yangh.reflection.question;

import com.yangh.Car;

public class GetClass {
    
    
    public static void main(String[] args) throws ClassNotFoundException {
    
    
        //1、Class.forName
        String classAllPath = "com.yangh.Car";//通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2、类名.class 应用场景：用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);

        //3、对象.getClass()
        Car car = new Car();
        Class<? extends Car> cls3 = car.getClass();
        System.out.println(cls3);

        //4、通过类加载器（类加载器有4种）来获取到类的Class对象
        //（1）先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //5、基本数据 （int，char，boolean，float，double，byte，long，short）按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        System.out.println(integerClass);
//        System.out.println(integerClass.hashCode());

        //6、基本数据类型对应的包装类，可以通过```.type```得到Class类对象
        Class<Integer> type = Integer.TYPE;
        System.out.println(type);
//        System.out.println(type.hashCode());

      /*  1到4是同一个类（哈希code相同），5和6都是同一个类（哈希code相同）*/
    }
}

4、哪些类有Class对象

外部类，成员内部类，静态类内部类，局部内部类，匿名内部类
interface接口
数组
enum枚举
annotation注解
基本数据类型
void

三、类加载

1、基本说明

反射机制是Java实现动态语言的关键，也就是通过反射实现类动态加载
1. 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
2. 动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性
类加载时机
1. 当创建对象时（new）【静态加载】
2. 当子类被加载时【静态加载】
3. 调用类中的静态成员时【静态加载】
4. 通过反射【动态加载】

2、类加载过程图

在这里插入图片描述

类加载的三个阶段：
1. 加载（Loading）：JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、jar包、甚至网络）文件读入内存，并为之创建一个java.lang.Class对象，此过程由类加载器完成
2. 连接（Linking）：将类的二进制数据合并到JRE中
  1. 验证：（1）目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全；（2）包括：文件格式验证（是否以魔数oxcafebabe开头）、元数据验证、字节码验证和符号引用验证；（3）可以考虑使用-Xverify:none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间
  2. 准备：JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如0，0L，null，false等）。这些变量所使用的内存都将在方法区中进行分配
  3. 解析：虚拟机将常量池内的符号引用替换成直接引用的过程
3. 初始化（initialization）：JVM负责对类进行初始化；（1）到初始化阶段才真正开始执行类中定义的Java程序代码，此阶段是执行()方法过程；（2）()方法是由编译器按语句在源码中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并；（3）虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多线程同时去初始化一个类，那么只会有一个线程执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕

四、反射获取类的结构信息

1、Class

1、getName：获取全类名
2、getSimpleName：获取简单类名
3、getFields：获取所有public修饰的属性，包含本类以及父类的
4、getDeclaredFields：获取本类中所有属性
5、getMethods：获取所有public修改的方法，包括本类以及父类的
6、getDeclaredMethods:获取本类中所有方法
7、getConstructors：获取本类所有public修饰的构造器
8、getDeclaredConstructors：获取本类中所有构造器
9、getPackage：以Package形式返回包信息
10、getSuperClass：以Class形式返回父类信息
11、getInterfaces：以Class[]形式返回接口信息
12、getAnnotations：以Annotatio[] 形式返回注解信息

package com.yangh.reflection.question;

import org.testng.annotations.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionUtils {
    
    
    public static void main(String[] args) {
    
    

    }
    //第一组方法API
    @Test
    public void api_01() throws ClassNotFoundException, NoSuchMethodException {
    
    
        //得到Class对象
        Class<?> personCls = Class.forName("com.yangh.reflection.question.Person");
        //1、getName：获取全类名
        System.out.println("全类名："+personCls.getName());

        //2、getSimpleName：获取简单类名
        System.out.println("简单类名："+personCls.getSimpleName());

        //3、getFields：获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field field : fields) {
    
    
            System.out.println("本类和父类的公有属性："+field.getName());
        }

        //4、getDeclaredFields：获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
    
    
            System.out.println("本类所有属性："+declaredField.getName());
        }

        //5、getMethods：获取所有public修改的方法，包括本类以及父类的
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
    
    
            System.out.println("本类和父类的公有方法："+method.getName());
        }

        //6、getDeclaredMethods:获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
    
    
            System.out.println("本类中所有方法："+declaredMethod.getName());
        }

        //7、getConstructors：获取本类所有public修饰的构造器
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> constructor : constructors) {
    
    
            System.out.println("本类公有构造器："+constructor.getName());
        }

        //8、getDeclaredConstructors：获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
    
    
            System.out.println("本类中所有构造器:"+declaredConstructor.getName());
        }

        //9、getPackage：以Package形式返回 包信息
        System.out.println(personCls.getPackage());

        //10、getSuperClass：以Class形式返回父类信息
        Class<?> superclass = personCls.getSuperclass();
        System.out.println("父类的class对象："+superclass);

        //11、getInterfaces：以Class[]形式返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
    
    
            System.out.println("接口信息:"+anInterface);
        }
        //12、getAnnotations：以Annotatio[] 形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
    
    
            System.out.println("注解信息："+annotation);
        }
    }
}

class A{
    
    
    public String hobby;
    public void hi(){
    
    }
    public A(){
    
    }

}

interface IA{
    
    

}

interface IB{
    
    

}

@Deprecated
class Person extends A implements IA,IB{
    
    
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    //构造器
    public Person(){
    
    }
    public Person(String name){
    
    }
    private Person(String name,int age){
    
    }

    //方法
    public void m1(){
    
    

    }
    protected void m2(){
    
    

    }
    void m3(){
    
    

    }
    private void m4(){
    
    

    }
}

2、Field、Method、Constructor细化的一些方法

@Test
    public void api_02() throws ClassNotFoundException {
    
    
        //得到Class对象
        Class<?> personCls = Class.forName("com.yangh.reflection.question.Person");
        //1、getDeclaredFields：获取本类中所有属性
        //（1）getName返回属性名
        //（2）getModifiers以int形式返回修饰符【默认修饰符为0；public为1；private为2，protected为4；static为8；final为16】
        //（3）getType以Class形式返回类型
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
    
    
            System.out.println("本类中所有属性："+declaredField.getName()+
                    "  该属性的修饰符值："+declaredField.getModifiers()+
                    "  该属性的类型："+declaredField.getType());
        }

        //2、getDeclaredMethods:获取本类中所有方法
        //（1）getName返回属性名
        //（2）getModifiers以int形式返回修饰符【默认修饰符为0；public为1；private为2，protected为4；static为8；final为16】
        //（3）getReturnType以Class形式返回类型
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
    
    
            System.out.print("本类中所有方法："+declaredMethod.getName()+
                    "  该方法的修饰符值："+declaredMethod.getModifiers()+
                    "  该方法的类型："+declaredMethod.getReturnType());

            //（4）以Class[]返回参数类型数组
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
    
    
                System.out.print("  该方法的形参类型："+parameterType);
            }
            System.out.println();
        }

        //3、getDeclaredConstructors：获取本类中所有构造器
        //（2）【这个不再演示】getModifiers以int形式返回修饰符【默认修饰符为0；public为1；private为2，protected为4；static为8；final为16】
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
    
    
            //（1）getName返回属性名
            System.out.print("本类中所有构造器:"+declaredConstructor.getName());

            //（3）getReturnType以Class形式返回类型
            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
    
    
                System.out.print("  该构造器的形参类型："+parameterType);
            }
            System.out.println();
        }
    }
}

3、通过反射创建对象

调用类中的public修饰的无参构造器
调用类中的指定构造器
Class类相关方法
getDeclaredConstructor().newInstance()：调用类中的无参构造器，获取对应类的对象
getConstuctor(Class…clazz)：根据参数列表，获取对应的构造器对象
getDecalaredConstructor(Class…clazz)：根据参数列表，获取对应的构造器对对象
Constructor类相关的方法:
setAccessible：暴破
newInstance(Object…obj)：调用构造器

4、通过反射访问类中属性

根据属性名获取Field对象Field f = clazz对象.getDeclaredField(属性名);
暴破：f.setAccessible(true);（f是Field）
访问

f.set(o.值);
syso(f.get(o));

注意：如果是静态属性，则set和get中的参数o可以写成null
实例：

package com.yangh.reflection.question;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class ReflectionF {
    
    
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    
    
        //1.得到Student类对应的 Class对象
        Class<?> stuClass = Class.forName("com.yangh.reflection.question.Student");

        //2.创建对象，o的运行类型就是Student
        Object o = stuClass.getDeclaredConstructor().newInstance();
        System.out.println(o.getClass());

        //3.使用反射得到age属性对象
        Field age = stuClass.getField("age");
        age.set(o,88);//通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));//获取属性值

        //4.使用反射操作name属性（静态私有属性）
        Field name = stuClass.getDeclaredField("name");
        //   对name进行暴破，可以操作private属性
        name.setAccessible(true);
        name.set(o,"老杨");//o可以写成null，因为name是静态的
        System.out.println(o);
    }
}
class Student{
    
    
    public int age;
    private static String name;
    public Student(){
    
    

    }
    
    @Override
    public String toString() {
    
    
        return "Student{" +
                "age=" + age +
                ", name=" + name +
                '}';
    }
}

5、通过反射访问类中方法

根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名,XX.class); //得到本类全部方法
获取对象：Object o = clazz.getDeclaredConstructor().newInstance();
暴破：m.setAccessible(true);
访问：Object returnValue = m.invoke(o,实参列表);
注意，如果是静态方法，则invoke的参数o可以写成null
实例：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class reflectionF2 {
    
    
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    
    
        //1.得到Boss类对应的Class对象
        Class<?> bossClass = Class.forName("com.yangh.reflection.question.Boss");
        //2.创建对象
        Object o = bossClass.getDeclaredConstructor().newInstance();
        //3.调用public的hi方法
        //(1)得到hi方法对象
        Method hi = bossClass.getMethod("hi",String.class);
        //（2）调用
        hi.invoke(o,"laoyang");

        //4.调用私有静态方法，要暴破
        Method say = bossClass.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);
        System.out.println(say.invoke(o,13,"yangh",'n'));
    }
}
class Boss{
    
    
    public int age;
    private static String name;

    private static String say(int n,String s,char c){
    
    
        return n+" "+s+" "+c;
    }
    public void hi(String s){
    
    
        System.out.println("hi "+s);
    }
}

Java基础之反射 笔记

Java基础之反射 笔记

一、反射机制（reflection）

1、通过示例对反射机制快速了解

2、反射机制基本介绍

二、Class类

1、基本介绍

2、Class常用方法

3、 获取Class对象的六种方式（getClass）

4、哪些类有Class对象

三、类加载

1、基本说明

2、类加载过程图

四、反射获取类的结构信息

1、Class

2、Field、Method、Constructor细化的一些方法

3、 通过反射创建对象

4、 通过反射访问类中属性

5、 通过反射访问类中方法

猜你喜欢

Java基础之反射笔记

Java基础之反射笔记

3、获取Class对象的六种方式（getClass）

3、通过反射创建对象

4、通过反射访问类中属性

5、通过反射访问类中方法