1. 首页
  2. 博客
  3. Java反射详解

Java反射详解

目录

  • 一、反射概述
    • 1. java.lang.Class:是反射的源头
  • 二、如何获取Class的实例
    • 1.调用运行时类本身的.class属性
    • 2.通过运行时类的对象获取
    • 3.通过Class的静态方法获取,通过此方式，体会反射的动态性
    • 4.通过类的加载器
  • 三、创建运行时类对象
    • 1. 获取Class的实例
    • 2.创建运行时类对象
  • 四、通过反射获取类的完整结构
    • 1.获取运行时类的属性
    • 2.获取属性的各个部分的内容
    • 3.获取运行时类的方法(重点)
    • 4.获取方法的各个部分的内容
    • 5.获取构造器
    • 6.获取运行时类的父类
    • 7.获取带泛型的父类
    • 8.获取父类的泛型(重点)
    • 9.获取实现的接口
    • 10.获取所在的包
  • 五、调用运行时类的指定结构
    • 1.调用运行时类指定的属性并赋值
    • 2.调用运行时类中指定的方法
    • 3.调用指定的构造器,创建类对象
  • 六、ClassLoader
    • 1. 描述一下JVM加载class文件的原理机制?

一、反射概述

1. java.lang.Class:是反射的源头

我们创建一个类，通过编译，生成对应的.calss文件，之后使用java.exe加载(jvm的类加载器)此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在缓存区，那么这个运行时类的本身就是一个class的实例

  • 每一个运行时类只加载一次
  • 有了Class实例以后，我们才可以进行如下的操作:
    • 创建对应的运行时类的对象(重点)
    • 可以获取对象的运行时类的完整结构（属性、方法、构造器、内部类、、、）（理解）
    • 调用对应的运行时类的指定的结构（属性、方法）（重点）

在反射以前，如何创建一个类的对象，并调用其中的方法属性

public void test1() {
        Person p = new Person();
        p.setAge(10);
        p.setName("AA");
        p.show();
        System.out.println(p);
    }

有了反射，可以通过反射创建一个类的对象，并调用其中的方法，下面详细说

public void test2() throws Exception {

        Class clazz = Person.class;

        //1.创建clazz对应的运行时类Person类的对象
        Person p = (Person)clazz.newInstance();
        System.out.println(p);

        //2.通过反射调用运行时类的指定属性，public name的修改方式
        Field f1 = clazz.getField("name");
        f1.set(p, "LiuDaHua");
        System.out.println(p);

        //private age的方式
        Field f2 = clazz.getDeclaredField("age");
        f2.setAccessible(true);
        f2.set(p, 20);
        System.out.println(p);

        //3.通过反射调用运行时类的指定方法 public修饰的
        Method m1 = clazz.getMethod("show");
        // 执行
        m1.invoke(p);
        // 带参数的方法
        Method m2 = clazz.getMethod("display", String.class);
        m2.invoke(p, "cn");

    }

二、如何获取Class的实例

1.调用运行时类本身的.class属性

Class clazz = Person.class;
System.out.println(clazz.getName());

Class clazz1 = String.class;
System.out.println(clazz1.getName());

2.通过运行时类的对象获取

Person p = new Person();
Class clazz2 = p.getClass();
System.out.println(clazz.getName());

3.通过Class的静态方法获取,通过此方式，体会反射的动态性

String className = "com.atguigu.java.Person";

Class clazz4 = Class.forName(className);       
System.out.println(clazz4);

4.通过类的加载器

ClassLoader classLoader = this.getClass().getClassLoader();
Class clazz5 = classLoader.loadClass(className);
System.out.println(clazz5.getName());

整个代码

public void test4() throws Exception {
        //1.调用运行时类本身的.class属性
        Class clazz = Person.class;
        System.out.println(clazz.getName());

        Class clazz1 = String.class;
        System.out.println(clazz1.getName());

        //2.通过运行时类的对象获取
        Person p = new Person();
        Class clazz2 = p.getClass();
        System.out.println(clazz.getName());

        //3.通过Class的静态方法获取,通过此方式，体会反射的动态性
        String className = "com.atguigu.java.Person";

        Class clazz4 = Class.forName(className);
        System.out.println(clazz4);


        //4.通过类的加载器
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class clazz5 = classLoader.loadClass(className);
        System.out.println(clazz5.getName());
    }

三、创建运行时类对象

1. 获取Class的实例

通常直接使用类名.class , 例如Person.class

当然了，上面的几种方法都是可以的

String className = "com.atguigu.java.Person";
Class clazz = Class.forName(className);

2.创建运行时类对象

创建对应的运行时类的对象，使用的是newInstance()，实际上就是运用了运行时类的空参数的构造器

要想能够创建成功

  • 要求对应的运行时类要有空参数的构造器
  • 构造器的权限修饰符的权限要足够
Object obj = clazz.newInstance();//调用的是空参构造器
Person p = (Person)obj;
System.out.println(p);

全部代码

public void test1() throws Exception {
    // 获取Class实例
        Class clazz = Person.class;

        //创建对应的运行时类的对象，使用的是newInstance()，实际上就是运用了运行时类的空参数的构造器
        //要想能够创建成功，①要求对应的运行时类要有空参数的构造器，②构造器的权限修饰符的权限要足够
        Object obj = clazz.newInstance();//调用的是空参构造器
        Person p = (Person)obj;
        System.out.println(p);      
    }

四、通过反射获取类的完整结构

1.获取运行时类的属性

1.getFields() 返回 ：表示公共字段的 Field 对象的数组，只能获取运行时类中以及父类中声明的为public的属性

Field[] fiels = clazz.getFields();
for(int i=0;i<fiels.length;i++) {
    System.out.println(fiels[i]);
    }

2.getDeclaredFields() ：获取运行时类本身声明的所有的属性，包括私有的

Field[] fiels1 = clazz.getDeclaredFields();
for(int i=0;i<fiels1.length;i++) {
    System.out.println(fiels1[i].getName());
    }
        //增强for循环
for(Field f:fiels1) {
    System.out.println(f.getName());
}

2.获取属性的各个部分的内容

权限修饰符 变量类型 变量名

1.获取每个属性的权限修饰符

Field[] field = clazz.getDeclaredFields();
    for(Field i:field) {
    //1.获取每个属性的权限修饰符
        int a = i.getModifiers();
        String str1 = Modifier.toString(a);
        System.out.print(str1+"   ");
    }

2.获取属性的变量类型

Field[] field = clazz.getDeclaredFields();
        for(Field i:field) {
        //2.获取属性的变量类型
        Class type = i.getType();
        System.out.print(type+"  ");
    }

3.获取属性名

Class clazz = Person.class;
        Field[] field = clazz.getDeclaredFields();
        for(Field i:field) {
        //3.获取属性名
        System.out.print(i.getName());
        System.out.println();
    }

3.获取运行时类的方法(重点)

1.getMethods() 获取运行时类及其父类中所有声明为public的方法

Class clazz = Person.class;
Method[] m1 = clazz.getMethods();
    for(Method m:m1) {
    System.out.println(m);
    }

2.getDeclaredMethods() 获取运行时类本身声明的所有的方法

Method[] methods = clazz.getDeclaredMethods();
    for(int i=0;i<methods.length;i++) {
        System.out.println(methods[i]);
    }

4.获取方法的各个部分的内容

注解 权限修饰符 返回值类型 方法名 形参列表 异常

1.注解

Class clazz = Person.class;

    Method[] m1 = clazz.getMethods();
    for(Method m:m1) {
    Annotation[] an = m.getAnnotations();
    for(Annotation a:an) {
        System.out.println(a);
    }
}

2.权限修饰符

int a = m.getModifiers();
String str1 = Modifier.toString(a);
System.out.print(str1+"  ");

3.返回值类型

Class return1 = m.getReturnType();
System.out.print(return1+"  ");

4.方法名

System.out.print(m.getName()+"   ");

5.形参列表

System.out.print("(");
Class[] params = m.getParameterTypes();
for(Class p : params) {
    System.out.print(p.getName());
}
System.out.println(")"+"   ");

6.抛的异常

Class[] ex = m.getExceptionTypes();
    for(Class e:ex) {
        System.out.print(e.getName());
    }
 //   for(int i=0;i<ex.length;i++) {
//  System.out.print(ex[i].getName());
 //       }

5.获取构造器

@Test
    public void test5() throws Exception {

        Class clazz = Class.forName("com.atguigu.java.Person");

        Constructor[] cons = clazz.getDeclaredConstructors();
        for(Constructor c : cons) {
            System.out.println(c);
        }


    }

6.获取运行时类的父类

@Test
    public void test6() {
        Class clazz = Person.class;
        Class super1 = clazz.getSuperclass();
        System.out.println(super1);
    }

7.获取带泛型的父类

@Test
    public void test7() {
        Class clazz = Person.class;
        Type type1 = clazz.getGenericSuperclass();
        System.out.println(type1);
    }

8.获取父类的泛型(重点)

@Test
    public void test8() {
        Class clazz = Person.class;
        Type type1 = clazz.getGenericSuperclass();

        ParameterizedType param= (ParameterizedType)type1;
        Type[] ars = param.getActualTypeArguments();
        System.out.println((Class)ars[0]);
    }

9.获取实现的接口

@Test
    public void test9() {
        Class clazz = Person.class;
        Class[] i = clazz.getInterfaces();
        for(Class a:i) {
            System.out.println(a);
        }
    }

10.获取所在的包

@Test
    public void test10() {
        Class clazz = Person.class;
        Package p = clazz.getPackage();
        System.out.println(p);
    }

全部代码如下：

package com.atguigu.java;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.junit.Test;

/**
 * 通过反射获取类的完整结构
 * 
 * @author MD
 *
 */
public class TestField {


    /**
     * 1.获取运行时类的属性
     */
    @Test
    public void test1() {
        Class clazz = Person.class;

        //1.getFields() 返回 ：表示公共字段的 Field 对象的数组 
        // 只能获取运行时类中以及父类中声明的为public的属性
//      Field[] fiels = clazz.getFields();
//      for(int i=0;i<fiels.length;i++) {
//          System.out.println(fiels[i]);
//      }

        //2.getDeclaredFields() ：获取运行时类本身声明的所有的属性
        Field[] fiels1 = clazz.getDeclaredFields();
        for(int i=0;i<fiels1.length;i++) {
            System.out.println(fiels1[i].getName());
        }
        //增强for循环
        for(Field f:fiels1) {
            System.out.println(f.getName());
        }


    }

    /**
     * 权限修饰符 变量类型  变量名
     * 2.获取属性的各个部分的内容
     * 
     */

    @Test
    public void tset2() {
        Class clazz = Person.class;
        Field[] field = clazz.getDeclaredFields();
        for(Field i:field) {
            //1.获取每个属性的权限修饰符
            int a = i.getModifiers();
            String str1 = Modifier.toString(a);
            System.out.print(str1+"   ");
            //2.获取属性的变量类型
            Class type = i.getType();
            System.out.print(type+"  ");
            //3.获取属性名
            System.out.print(i.getName());
            System.out.println();
        }
    }





    /**
     * 3.获取运行时类的方法
     */
    @Test
    public void test3() {
        Class clazz = Person.class;

        //1.getMethods() 获取运行时类及其父类中所有声明为public的方法

//      Method[] m1 = clazz.getMethods();
//      for(Method m:m1) {
//          System.out.println(m);
//      }


        //2.getDeclaredMethods() 获取运行时类本身声明的所有的方法
        Method[] methods = clazz.getDeclaredMethods();
        for(int i=0;i<methods.length;i++) {
            System.out.println(methods[i]);
        }
    }

    /**
     * 4.获取方法的各个部分的内容
     * 注解  权限修饰符   返回值类型    方法名    形参列表    异常
     * 
     */
    @Test
    public void test4() {
        Class clazz = Person.class;

        Method[] m1 = clazz.getMethods();
        for(Method m:m1) {
            //1.注解
            Annotation[] an = m.getAnnotations();
            for(Annotation a:an) {
                System.out.println(a);
            }

            //2.权限修饰符
            int a = m.getModifiers();
            String str1 = Modifier.toString(a);
            System.out.print(str1+"  ");

            //3.返回值类型
            Class return1 = m.getReturnType();
            System.out.print(return1+"  ");


            //4.方法名
            System.out.print(m.getName()+"   ");

            //5.形参列表
            System.out.print("(");
            Class[] params = m.getParameterTypes();
            for(Class p : params) {
                System.out.print(p.getName());
            }
            System.out.println(")"+"   ");

            //6.抛的异常
            Class[] ex = m.getExceptionTypes();
            for(Class e:ex) {
                System.out.print(e.getName());
            }
//          for(int i=0;i<ex.length;i++) {
//              System.out.print(ex[i].getName());
//          }

            System.out.println();
        }


    }

    /**
     * 5.获取构造器
     * @throws Exception 
     */

    @Test
    public void test5() throws Exception {

        Class clazz = Class.forName("com.atguigu.java.Person");

        Constructor[] cons = clazz.getDeclaredConstructors();
        for(Constructor c : cons) {
            System.out.println(c);
        }
    }

    /**
     * 
     * 6.获取运行时类的父类
     */
    @Test
    public void test6() {
        Class clazz = Person.class;
        Class super1 = clazz.getSuperclass();
        System.out.println(super1);
    }


    /**
     * 7.获取带泛型的父类
     */

    @Test
    public void test7() {
        Class clazz = Person.class;
        Type type1 = clazz.getGenericSuperclass();
        System.out.println(type1);
    }


    /**
     * 8.获取父类的泛型
     */
    @Test
    public void test8() {
        Class clazz = Person.class;
        Type type1 = clazz.getGenericSuperclass();

        ParameterizedType param= (ParameterizedType)type1;
        Type[] ars = param.getActualTypeArguments();
        System.out.println((Class)ars[0]);
    }

    /**
     * 9.获取实现的接口
     */
    @Test
    public void test9() {
        Class clazz = Person.class;
        Class[] i = clazz.getInterfaces();
        for(Class a:i) {
            System.out.println(a);
        }
    }

    /**
     * 10.获取所在的包
     */
    @Test
    public void test10() {
        Class clazz = Person.class;
        Package p = clazz.getPackage();
        System.out.println(p);
    }
}

五、调用运行时类的指定结构

1.调用运行时类指定的属性并赋值

1. 获取指定的属性

getField(String fieldName):获取运行时类中声明为public的指定的属性名为fieldName的属性

Field name = clazz.getField("name");

2.创建运行时类的对象

Person p = (Person) clazz.newInstance();
System.out.println(p);

3.将运行时类的指定属性赋值

name.set(p, "Jerry");
System.out.println(p);

给age赋值,private需要注意

getDeclareField(String fieldName):获取运行时类中指明为filedName的属性

Field age = clazz.getDeclaredField("age");
    //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作
    age.setAccessible(true);//私有的设置成可以访问的
    age.set(p,1);
    System.out.println(p);

给id赋值，默认的修饰符

Field id = clazz.getDeclaredField("id");
    id.set(p,10);
    System.out.println(p);

2.调用运行时类中指定的方法

1.getMethod(String methodName,Class...params)获取指定的public方法，方法名，参数列表

Class clazz = Person.class;
Method m1 = clazz.getMethod("show");

2.创建运行时类的对象

Person p =(Person)clazz.newInstance();

3.和属性相似，这里是invoke关键字里面是对象和参数列表，或许还有返回值，用Object接收

Object returnVal = m1.invoke(p);
System.out.println(returnVal);//没返回值的打印为null

4.获取toString()有返回值的

Method m2 = clazz.getMethod("toString");
Object returnVal1 = m2.invoke(p);
System.out.println(returnVal1);

5.获取display()带参数的

Method m3 = clazz.getMethod("display",String.class);
m3.invoke(p, "china");

6.获取info()静态的方法

Method m4 = clazz.getMethod("info");
m4.invoke(Person.class);

7.获取Test() 私有的带参数的有返回值的

Method m5 = clazz.getDeclaredMethod("Test",String.class,Integer.class);
m5.setAccessible(true);
Object o = m5.invoke(p,"测试",5);
System.out.println(o);

3.调用指定的构造器,创建类对象

public void test3() throws InstantiationException, Exception {
        Class clazz = Person.class;
        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
        cons.setAccessible(true);
        Person p = (Person)cons.newInstance("迪丽热巴",20);
        System.out.println(p);


    }

全部代码

package com.atguigu.java;

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

import org.junit.Test;

/**
 * ******调用对应的运行时类的指定的结构（属性、方法）
 * @author MD
 *
 */
public class TestField1 {
    /**
     * 调用运行时类指定的属性
     * @throws Exception 
     * @throws NoSuchFieldException 
     */

    @Test
    public void test1() throws Exception {
        Class clazz = Person.class;

        //1.获取指定的属性
        //getField(String fieldName):获取运行时类中声明为public的指定的属性名为fieldName的属性
        Field name = clazz.getField("name");
        //2.创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        System.out.println(p);
        //3.将运行时类的指定属性赋值
        name.set(p, "Jerry");
        System.out.println(p);

        //给age赋值,private需要注意
        //getDeclareField(String fieldName):获取运行时类中指明为filedName的属性
        Field age = clazz.getDeclaredField("age");
        //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作
        age.setAccessible(true);//私有的设置成可以访问的
        age.set(p,1);
        System.out.println(p);

        //给id赋值，默认的修饰符
        Field id = clazz.getDeclaredField("id");
        id.set(p,10);
        System.out.println(p);

    }

    /**
     * 调用运行时类中指定的方法
     * @throws Exception 
     * @throws NoSuchMethodException 
     */
    @Test
    public void test2() throws NoSuchMethodException, Exception {
        Class clazz = Person.class;

        //getMethod(String methodName,Class...params)获取指定的public方法，方法名，参数列表
        Method m1 = clazz.getMethod("show");

        //创建运行时类的对象
        Person p =(Person)clazz.newInstance();

        //和属性相似，这里是invoke关键字里面是对象和参数列表，或许还有返回值，用Object接收
        Object returnVal = m1.invoke(p);
        System.out.println(returnVal);

        //获取toString()有返回值的
        Method m2 = clazz.getMethod("toString");
        Object returnVal1 = m2.invoke(p);
        System.out.println(returnVal1);

        //获取display()带参数的
        Method m3 = clazz.getMethod("display",String.class);
        m3.invoke(p, "china");

        //获取info()静态的方法
        Method m4 = clazz.getMethod("info");
        m4.invoke(Person.class);

        //获取Test() 私有的带参数的有返回值的
        Method m5 = clazz.getDeclaredMethod("Test",String.class,Integer.class);
        m5.setAccessible(true);
        Object o = m5.invoke(p,"测试",5);
        System.out.println(o);  
    }


    /**
     * 调用指定的构造器,创建类对象
     * @throws Exception 
     * @throws InstantiationException 
     */

    @Test
    public void test3() throws InstantiationException, Exception {
        Class clazz = Person.class; 
        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
        cons.setAccessible(true);
        Person p = (Person)cons.newInstance("迪丽热巴",20);
        System.out.println(p);
    }
}

六、ClassLoader

类加载器是用来把类(class)装载进内存

1.获取一个系统类加载器

ClassLoader loader1 = ClassLoader.getSystemClassLoader();
System.out.println(loader1);

2.获取系统类加载器的父类加载器，即扩展类加载器

ClassLoader loader2 = loader1.getParent();
System.out.println(loader2);

3.获取扩展类加载器的父类加载器，即引导类加载器,加载的是核心库，打印为null

ClassLoader loader3 = loader2.getParent();
System.out.println(loader3);

4.测试当前类由哪个类加载器进行加载

Class clazz1 = Person.class;
ClassLoader loader4 = clazz1.getClassLoader();
System.out.println(loader4);//系统类加载器

1. 描述一下JVM加载class文件的原理机制?

JVM中类的装载是由ClassLoader和它的子类来实现的,

Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

原文链接：https://www.cnblogs.com/mengd/p/13400005.html

热门标签