浅谈Java之反射

反射

• • 四种获取Class实例的方法
  • 定义测试结构
  • 获取属性结构
  • 获取方法结构
  • 获取构造器结构(包括父类泛型)
  • 获取实现的接口
  • 获取所在包
  • 获取注解
  • 获取并创建指定构造器
  • 获取指定属性
  • 获取并运行指定方法

四种获取Class实例的方法

1. 调用运行时类的属性
2. 通过运行时类的对象，调用getClass()
3. 调用Class静态方法：forName(String classPath) 开发中最常用
4. 使用类的加载器：ClassLoader (了解就行)

package day_12_29;

import org.junit.Test;

/**
 * @author soberw
 * @Classname ReflectionTest
 * @Description 反射之获取Class的实例的四种方式
 * @Date 2021-12-29 20:44
 */
public class ReflectionTest {
    //获取Person类
    @Test
    public void test() {
        //1.调用运行时类的属性
        Class<Person> clazz1 = Person.class;
        System.out.println(clazz1);

        //2. 通过运行时类的对象，调用getClass()
        Person p1 = new Person();
        Class<? extends Person> clazz2 = p1.getClass();
        System.out.println(clazz2);

        //3. 调用Class静态方法：forName(String classPath)  开发中最常用
        Class<?> clazz3 = null;
        try {
            clazz3 = Class.forName("day_12_29.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(clazz3);

        //4. 使用类的加载器：ClassLoader  (了解就行)
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class<?> clazz4 = null;
        try {
            clazz4 = classLoader.loadClass("day_12_29.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(clazz4);

    }

}
//将要获取到的类
class Person {

}

定义测试结构

获取属性结构

获取类中的属性：

getFields():获取当前运行时类以及所有父类的声明为public访问权限的属性

getDeclaredFields():获取当前运行时类中声明的所有属性（与权限修饰无关，且不包含父类中声明的属性）

获取属性的内部结构：

1.getModifiers()：获取权限修饰符，返回值为int类型，对应的是修饰符的值，可通过Modifier.toString(...)获得

2.getType():数据类型，返回Class类型，可通过.getName()获得全类名

3.getName():返回变量名，String类型

package day_12_30.reflection.test;

import day_12_30.reflection.java.Person;
import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @author soberw
 * @Classname FieldTest
 * @Description  获取当前运行时类的属性结构
 * @Date 2021-12-30 14:54
 */
public class FieldTest {
    //获取当前运行时类（Class实例）
    Class<Person> clazz = Person.class;

    @Test
    public void test1(){
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
            /*
            public int day_12_30.reflection.java.Person.id
            public double day_12_30.reflection.java.Creature.weight
             */
        }
        System.out.println();

        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
            /*
            private java.lang.String day_12_30.reflection.java.Person.name
            int day_12_30.reflection.java.Person.age
            public int day_12_30.reflection.java.Person.id
             */
        }

    }
    //权限修饰符  数据类型 变量名
    @Test
    public void test2(){
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f : declaredFields) {
            //1.权限修饰符
            int modifier = f.getModifiers();
            System.out.print(Modifier.toString(modifier) + "\t");

            //2.数剧类型
            Class<?> type = f.getType();
            System.out.print(type.getName() + "\t");

            //3,变量名
            String name = f.getName();
            System.out.print(name);

            System.out.println();
        }
        /*
        private	java.lang.String	name
        	int	age
        public	int	id
         */
    }
}

获取方法结构

获取类中的方法：

getMethods():获取当前运行时类以及所有父类的声明为public访问权限的方法

getDeclaredMethods():获取当前运行时类中声明的所有方法（与权限修饰无关，且不包含父类中声明的）

注意：重写的方法也能获取到

获取方法的内部结构：

-    @Xxxx
-    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}

1.getAnnotations() 获取方法的全部声明注解，返回为Annotation[]数组

2.getModifiers()获取方法的权限修饰符

3.getReturnType()获取返回值类型，可通过.getName()获得具体名字

4.getName()方法名

5.getParameterTypes()：形参列表。返回为通过Class[]数组。.getName()获得具体名字

6.getExceptkionTypes(): 获得跑出的异常类型。返回为通过Class[]数组。.getName()获得具体名字

package day_12_30.reflection.test;

import day_12_30.reflection.java.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @author soberw
 * @Classname MethodTest
 * @Description  获取运行时类的方法结构
 * @Date 2021-12-30 15:05
 */
public class MethodTest {
    Class<Person> clazz = Person.class;
    @Test
    public void test1(){
        Method[] methods = clazz.getMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
        /*
        public java.lang.String day_12_30.reflection.java.Person.toString()
        public int day_12_30.reflection.java.Person.compareTo(java.lang.String)
        public int day_12_30.reflection.java.Person.compareTo(java.lang.Object)
        public void day_12_30.reflection.java.Person.info()
        public java.lang.String day_12_30.reflection.java.Person.display(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ClassCastException
        public void day_12_30.reflection.java.Creature.eat()
        public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
        public final void java.lang.Object.wait() throws java.lang.InterruptedException
        public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
        public boolean java.lang.Object.equals(java.lang.Object)
        public native int java.lang.Object.hashCode()
        public final native java.lang.Class java.lang.Object.getClass()
        public final native void java.lang.Object.notify()
        public final native void java.lang.Object.notifyAll()
         */
        System.out.println();
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m);
        }
        /*
        public java.lang.String day_12_30.reflection.java.Person.toString()
        public int day_12_30.reflection.java.Person.compareTo(java.lang.String)
        public int day_12_30.reflection.java.Person.compareTo(java.lang.Object)
        public void day_12_30.reflection.java.Person.info()
        public java.lang.String day_12_30.reflection.java.Person.display(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ClassCastException
        private static void day_12_30.reflection.java.Person.showDesc()
        private java.lang.String day_12_30.reflection.java.Person.show(java.lang.String)
         */
    }
    /*
    @Xxxx
    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
     */
    @Test
    public void test2(){
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            //1.获取注解
            Annotation[] annotations = m.getAnnotations();
            for (Annotation a : annotations) {
                System.out.println(a);
            }
            //2，权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");
            //3.返回值类型
            System.out.print(m.getReturnType().getName()+"\t");
            //4.方法名
            System.out.print(m.getName());
            System.out.print("( ");
            //5.形参列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                for(int i = 0;i < parameterTypes.length;i++){
                    if(i == parameterTypes.length - 1){
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                }
            }
            System.out.print(" )");
            //6.抛出的异常
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            if(exceptionTypes.length > 0){
                System.out.print("throws ");
                for(int i = 0;i < exceptionTypes.length;i++){
                    if(i == exceptionTypes.length - 1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }

                    System.out.print(exceptionTypes[i].getName() + ",");
                }
            }
            System.out.println();
        }
        /*
        public	java.lang.String	toString(  )
        public	int	compareTo( java.lang.String args_0 )
        public volatile	int	compareTo( java.lang.Object args_0 )
        public	void	info(  )
        public	java.lang.String	display( java.lang.String args_0,int args_1 )throws java.lang.NullPointerException,java.lang.ClassCastException
        @day_12_30.reflection.java.MyAnnotation("soberw")
        private	java.lang.String	show( java.lang.String args_0 )
        private static	void	showDesc(  )
         */
    }

}

获取构造器结构(包括父类泛型)

获取当前运行类中的构造器

1.getConstructors():获取当前运行时类中声明为public的构造器

2.getDelaredConstructors():获取当前运行时类中声明的所有的构造器

获取父类(也可以是带泛型的)——比较常用

1.getSuperclass():获取运行时类的父类

2.getGenericSuperclass():获取运行时的带泛型的父类

3.获取运行时类的带泛型的父类的泛型，在上一步之后，得到一个返回值为Type类型的返回值

​ 调用其getActualTypeArguments()方法获得Type[]即所有泛型的类型，在通过getName()获

​ 取名字

    @Test
    public void test1(){
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> c : constructors) {
            System.out.println(c);
            /*
            public day_12_30.reflection.java.Person(java.lang.String,int)
            public day_12_30.reflection.java.Person()
             */
        }
        System.out.println();
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor<?> d : declaredConstructors) {
            System.out.println(d);
            /*
            public day_12_30.reflection.java.Person(java.lang.String,int)
            private day_12_30.reflection.java.Person(java.lang.String)
            public day_12_30.reflection.java.Person()
             */
        }
    }
    /**
     * 获取父类(包括带泛型的，以及其泛型）
     */
    @Test
    public void test3(){
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);
        //class day_12_30.reflection.java.Creature

        //获取运行时类的带泛型的父类
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
        //day_12_30.reflection.java.Creature<java.lang.String>

        //获取运行时类的带泛型的父类的泛型
        //转换为参数化类型，即为泛型
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型的参数
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        for (Type a : actualTypeArguments) {
            //两种都可
            //System.out.println(a.getTypeName());
            System.out.println(((Class<?>)a).getName());
            //java.lang.String
        }
    }

获取实现的接口

获取运行时类实现的接口(以及泛型)

getInterfaces()返回Class[] ,实现的所有接口，不包括父类实现的

getGenericInterfaces():返回运行时类直接实现的接口的类型

获取运行时类的父类实现的接口

getSuperclass().getInterfaces()

@Test
    public void test4(){
        //获取运行时类实现的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> c : interfaces) {
            System.out.println(c);
            /*
            interface day_12_30.reflection.java.MyInterface
            interface java.lang.Comparable
             */
        }
        System.out.println();
        //获取运行时类的父类实现的接口
        Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class<?> c : interfaces1) {
            System.out.println(c);
            //interface java.io.Serializable
        }
        System.out.println();
        //返回运行时类直接实现的接口的类型。
        Type[] genericInterfaces = clazz.getGenericInterfaces();
        for (Type g : genericInterfaces) {
            System.out.println(g.getTypeName());
            /*
            day_12_30.reflection.java.MyInterface
            java.lang.Comparable<java.lang.String>
             */
        }
    }

获取所在包

getPackage()

@Test
    public void test5(){
        Package aPackage = clazz.getPackage();
        System.out.println(aPackage);
        //package day_12_30.reflection.java
    }

获取注解

注解要想通过反射获得，必须生命周期为运行时RUNTIME的注解

getAnnotations() 返回一个数组，因为可能多个注解Annotation[]

 @Test
 public void test6(){
     Annotation[] annotations = clazz.getAnnotations();
     for (Annotation a : annotations) {
           System.out.println(a);
           //@day_12_30.reflection.java.MyAnnotation("soberw")
     }
}

获取并创建指定构造器

分为三步走：

1. 获取指定的构造器getDeclaredConstrutor():参数：指定构造器的参数列表（这里我们一般都会调用无参的）,返回值为Constructor类型
2. 保证构造器是可访问的setAccessible(true):设置为true，私有的也能调用
3. 调用构造器创建运行时类的对象newInstance():可变形参，默认为空参

获取指定属性

首先第一步：必须先通过构造器去声明一个运行时类的对象

获取声明为public 的属性(不常用)

getField(String name)获取属性（必须是public）

set(两个参数)第一个为指定的对象，第二个为设置的值

get(一个参数)获取指定对象的当前属性值

获取并操作运行时类中的指定的属性（比较常用）

同样三步走：

1. 获取运行时类中指定的变量名的属性getDeclaredField()，返回值为Field类型

2. 保证当前属性是可访问的：setAccessible(true)

3. 获取、设置指定对象的此属性值

   set(两个参数)第一个为指定的对象，第二个为设置的值

   get(一个参数)获取指定对象的当前属性值

获取并运行指定方法

通过getMethod(String name,Class c)获取的实际开发中并不常用，因为只能获取public的，不再细说

获取并操作运行时类的指定的方法（比较常用）

首先第一步：必须先通过构造器去声明一个运行时类的对象

接下来四步走：

1. getDeclaredMethod()： 参数1：指明获取方法的名称。参数2：指明方法形参列表（因为存在重载情况），返回值为Method类型

2. 保证当前属性是可访问的：setAccessible(true)

3. 调用invoke()以运行此方法，参数1：方法的调用者（一般为声明的对象） 参数2：方法实参（传入参数，若无参则为空）

4. 返回值，invoke()方法可以有返回值，Object类型的

若原方法无返回值(void)，则返回null

若原方法有返回值，则invoke()会返回指定的类型

另外注意

• 若是调用类的静态方法，我们同样需要先声明对象，然后通过名字得到对应方法
• 只是在指定调用者的时候，不能再指定为声明的对象，而是运行类本身，或者写为null

package day_12_30.reflection.test;

import day_12_30.reflection.java.Person;
import org.junit.Test;

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

/**
 * @author soberw
 * @Classname ReflectionTest
 * @Description 调用运行时类中指定的结构：属性、方法、构造器
 * @Date 2021-12-30 15:52
 */
public class ReflectionTest {
    Class<Person> clazz = Person.class;

    //构造器
    @Test
    public void test1() throws Exception {
        Constructor<Person> constructor = clazz.getDeclaredConstructor();
        Person person = constructor.newInstance();
        System.out.println(person);
        //Person{name='null', age=0, id=0}

        //获取私有构造器
        Constructor<Person> declaredConstructor = clazz.getDeclaredConstructor(String.class);
        //将访问权限打开
        declaredConstructor.setAccessible(true);
        Person soberw = declaredConstructor.newInstance("soberw");
        System.out.println(soberw);
        //Person{name='soberw', age=0, id=0}
    }

    //属性
    @Test
    public void test2() throws Exception {
        //第一步： 一定要先创建对象
        Person person = clazz.getDeclaredConstructor().newInstance();
        Field pname = clazz.getDeclaredField("name");
        pname.setAccessible(true);
        pname.set(person, "soberw");
        System.out.println(pname.get(person));
        //soberw
    }

    //方法
    @Test
    public void test3() throws Exception {
        Person person = clazz.getDeclaredConstructor().newInstance();
        Method show = clazz.getDeclaredMethod("show", String.class);
        show.setAccessible(true);
        Object invoke = show.invoke(person, "中国");
        //我的国籍是中国
        System.out.println(invoke);
        //中国
        //调用静态方法
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        Object val1 = showDesc.invoke(null);
        //我是一个可爱的人
        Object val2 = showDesc.invoke(clazz);
        //我是一个可爱的人
        Object val3 = showDesc.invoke(Person.class);
        //我是一个可爱的人
        System.out.println(val1);
        //null
        System.out.println(val2);
        //null
        System.out.println(val3);
        //null
    }
}