13 反射 - 反射的应用 - 《JavaSE》

创建运行时类的对象
获取运行时类的完整结构
调用运行时类的指定结构

javajavase

创建运行时类的对象

调用 **newInstance()** 方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器
要想此方法正常的创建运行时类的对象，要求

运行时类必须提供空参的构造器
空参的构造器的访问权限得够。通常设置为public

在 javabean 中要求提供一个 public 的空参构造器，原因

便于通过反射，创建运行时类的对象

便于子类继承此运行时类时，默认调用 super() 时，保证父类此构造器

@Test
public void test1() throws IllegalAccessException, InstantiationException {
 Class<Person> clazz = Person.class;
 Person obj = clazz.newInstance();    // 上面不用泛型得到的是Object类，得强转
 System.out.println(obj);
}

体会反射的动态性 ```java public void test2() { for(int i = 0; i < 100; i++) {

 int num = new Random().nextInt(3);    // 0,1,2
 String classPath = "";
 switch(num) {
     case 0:
         classPath = "java.util.Date";
         break;
     case 1:
         classPath = "java.lang.Object";
         break;
     case 2:
         classPath = "com.cess.java.Person";
         break;
 }
 try {
     Object obj = getInstance(classPath);
     System.out.println(obj);
 } catch (Exception e) {
     e.printStackTrace();
 }

} }

// 创建一个指定类的对象。 // classPath:指定类的全类名 public Object getInstance(String classPath) throws Exception { Class clazz = Class.forName(classPath); return clazz.newInstance(); }

**难道没有无参的构造器就不能创建对象了吗？**<br />不是！只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。 步骤如下
1. 通过Class类的 `**getDeclaredConstructor(Class... parameterTypes)**` 取得本类的指定形参类型的构造器
1. 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
1. 通过Constructor实例化对象
```java
// 1.根据全类名获取对应的Class对象
String name = “atguigu.java.Person";
Class clazz = Class.forName(name);
// 2.调用指定参数结构的构造器，生成Constructor的实例
Constructor con = clazz.getConstructor(String.class, Integer.class);
// 3.通过Constructor的实例创建对应类的对象，并初始化类属性
Person p2 = (Person) con.newInstance("Peter", 20);
System.out.println(p2);

获取运行时类的完整结构

// 创建Class的实例
String str = "test1.Person";
Class clazz = Class.forName(str);
// 调用Class的空参构造器创建对象
Object obj = clazz.newInstance();
// 获取clazz的name属性
Field field = clazz.getField("name");
field.set(obj, "Jarry");
Object name = filed.get(obj);
System.out.println(name);

通过反射，获取对应的运行时类中所有的属性、方法、构造器、父类、接口、父类的泛型、包、注解、异常等

使用反射可以取得

实现的全部接口

**public Class<?>[] getInterfaces()** 确定此对象所表示的类或接口实现的接口

所继承的父类

**public Class<? Super T> getSuperclass()**
返回表示此 Class所表示的实体(类/接口/基本类型)的父类的Class

全部的构造器

**Constructor<T> getConstructor(Class<?>... parameterTypes)**
**Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)**
**public Constructor<T>[] getConstructors()** 返回此Class对象所表示的类的所有public构造器
**public Constructor<T>[] getDeclaredConstructors()**
返回此Class对象表示的类声明的所有构造器。在Constructor类中

**public int getModifiers();** 取得修饰符
**public String getName();** 取得名称
**public Class<?> getParameterTypes();** 取得参数的类型

全部的方法

**Method getMethod(String name, Class<?>... parameterTypes)**
**Method getDeclaredMethod(String name, Class<?>... parameterTypes)**
**public Method[] getMethods()** 返回此Class对象所表示的类或接口的public的方法Method类中
**public Method[] getDeclaredMethods()** 返回此Class对象所表示的类或接口的全部方法

属性

**Field getField(String name)**
**Field getDeclaredField(String name)**
**public Field[] getFields()** 返回此Class对象所表示的类或接口的public的属性，包括继承的
**public Field[] getDeclaredFields()** 返回此Class对象所表示的类或接口的全部属性，不包括父类

Annotation相关
**getAnnotation(Class<T> annotationClass)**
**getDeclaredAnnotations()**
泛型相关
**Type getGenericSuperclass()** 获取父类泛型类型
**ParameterizedType** 泛型类型
**getActualTypeArguments()** 获取实际的泛型类型参数数组
类所在的包

**Package getPackage()**

Field
**public int getModifiers()** 以整数形式返回此Field的修饰符
**public String getName()** 返回Field的名称
**public Class<?> getType()** 得到Field的属性类型

Method
**public Class<?> getReturnType()** 取得全部的返回值
**public Class<?>[] getParameterTypes()** 取得全部的参数
**public int getModifiers()** 取得修饰符
**public Class<?> [] getEXceptionTypes()** 取得异常信息

Constructor
**T newInstance(Object ... initargs)**

AccessibleObject
**void setAccessible(boolean flag)** 设置可以直接访问私有属性

public class Creature<T> implements Serializable {
    private char gender;
    public double weight;
    private void breath() {
        System.out.println("生物呼吸");
    }
    public void eat() {
        System.out.println("生物吃东西");
    }
}
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}
public interface MyInterface {
    void info();
}

@MyAnnotation(value="hi")
public class Person extends Creature<String> implements Comparable<String>, MyInterface {
    private String name;
    int age;
    public int id;
    public Person() {}
    @MyAnnotation(value="abc")
    private Person(String name) {
        this.name = name;
    }
    Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    @MyAnnotation
    private String show(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }
    public String display(String interests,int age) 
        throws NullPointerException,ClassCastException {
        return interests + age;
    }
    @Override
    public void info() {
        System.out.println("我是一个人");
    }
    @Override
    public int compareTo(String o) {
        return 0;
    }
    private static void showDesc(){
        System.out.println("我是一个可爱的人");
    }
    //getXxx() setXxx() toString()略
}

获取属性Field

public class FieldTest {
    @Test
    public void test1() {
        Class clazz = Person.class;
        // 获取属性结构
        // getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field f : fields) {
            System.out.println(f);
        }
        System.out.println();
        // getDeclaredFields():获取当前运行时类自己声明的所有属性。（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f : declaredFields) {
            System.out.println(f);
        }
    }
    // 权限修饰符 数据类型 变量名
    @Test
    public void test2() {
        Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f : declaredFields) {
            // 1.权限修饰符
            int modifier = f.getModifiers();    // 获取的是一个数字
            // Modifier将数字转换为字符串
            System.out.print(Modifier.toString(modifier) + "\t");
            // 2.数据类型
            Class type = f.getType();
            System.out.print(type.getName() + "\t");
            // 3.变量名
            String fName = f.getName();
            System.out.print(fName);
            System.out.println();
        }
    }
}

获取方法Method

public class MethodTest {
    @Test
    public void test1(){
        Class clazz = Person.class;
        // getMethods():获取当前运行时类及其所有父类中声明为public的方法
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }
        System.out.println();
        // getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }
    }
    /*
    @Xxxx
    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
     */
    @Test
    public void test2() {
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods) {
            // 1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for(Annotation a : annos) {
                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 class OtherTest {
    /*
        获取构造器结构
     */
    @Test
    public void test1() {
        Class clazz = Person.class;
        // getConstructors():获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c : constructors) {
            System.out.println(c);
        }
        System.out.println();
        // getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : declaredConstructors) {
            System.out.println(c);
        }
    }
    /*
        获取运行时类的父类
     */
    @Test
    public void test2() {
        Class clazz = Person.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }
    /*
        获取运行时类的带泛型的父类
     */
    @Test
    public void test3() {
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }
    /*
        获取运行时类的带泛型的父类的泛型
        代码：逻辑性代码  vs 功能性代码
     */
    @Test
    public void test4() {
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        // 获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
//        System.out.println(actualTypeArguments[0].getTypeName());
        System.out.println(((Class)actualTypeArguments[0]).getName());
    }
    /*
        获取运行时类实现的接口
     */
    @Test
    public void test5() {
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for(Class c : interfaces) {
            System.out.println(c);
        }
        System.out.println();
        // 获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c : interfaces1) {
            System.out.println(c);
        }
    }
    /*
        获取运行时类所在的包
     */
    @Test
    public void test6() {
        Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);
    }
    /*
        获取运行时类声明的注解
     */
    @Test
    public void test7(){
        Class clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annos : annotations) {
            System.out.println(annos);
        }
    }
}

小结

在实际的操作中，取得类的信息的操作代码，并不会经常开发
一定要熟悉 java.lang.reflect 包的作用，反射机制
如何取得属性、方法、构造器的名称，修饰符等
调用运行时类的指定结构
调用运行时类中指定的结构：属性、方法、构造器
调用指定的属性

在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作

**public Field getField(String name)** 返回此 Class 对象表示的类或接口的指定的public的Field
**public Field getDeclaredField(String name)** 返回此 Class 对象表示的类或接口的指定的Field

在 Field 中

**public Object get(object obj)** 取得指定对象 obj 上此 Field 的属性内容
**public void set(Object obj,Object value)** 设置指定对象 obj 上此 Field 的属性内容

/*
    不需要掌握
 */
@Test
public void testField() throws Exception {
    Class clazz = Person.class;
    // 创建运行时类的对象
    Person p = (Person) clazz.newInstance();
    // 获取指定的属性：要求运行时类中属性声明为 public
    // 通常不采用此方法 属性基本都不是public的
    Field id = clazz.getField("id");
    // 设置当前属性的值
    // set():参数1：指明设置哪个对象的属性   参数2：将此属性值设置为多少
    id.set(p, 1001);
    // 获取当前属性的值
    // get():参数1：获取哪个对象的当前属性值
    int pId = (int) id.get(p);
    System.out.println(pId);
}
/*
    如何操作运行时类中的指定的属性 -- 需要掌握
 */
@Test
public void testField1() throws Exception {
    Class clazz = Person.class;
    // 创建运行时类的对象
    Person p = (Person) clazz.newInstance();
    // 1. getDeclaredField(String fieldName)：获取运行时类中指定变量名的属性
    Field name = clazz.getDeclaredField("name");
    // 2.保证当前属性是可访问的
    name.setAccessible(true);
    // 3.获取、设置指定对象的此属性值
    name.set(p, "Tom");
    System.out.println(name.get(p));
}

调用指定的方法（常用）

通过反射，调用类中的方法，通过Method类完成。步骤:

通过Class类的 **getMethod(String name, Class… parameterTypes)** 方法取得一个Method对象，并设置此方法操作时所需要的参数类型
之后使用 Object invoke(Object obj, Object[] args) 进行调用，并向方法中传递要设置的obj对象的参数信息

反射的应用 - 图1
**Object invoke(Object obj, Object... args)**

Object 对应原方法的返回值，若原方法无返回值，此时返回 null
若原方法若为静态方法，此时形参 Object obj 可为 null
若原方法形参列表为空，则 Object… args 为 null
若原方法声明为 private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法

关于setAccessible方法的使用

Method、Field、Constructor对象都有setAccessible()方法
setAccessible是启动和禁用访问安全检查的开关
参数值为true则指示反射的对象在使用时应该取消Java语言访问检査
提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问

参数值为false则指示反射的对象应该实施Java语言访问检査

/*
  如何操作运行时类中的指定的方法 -- 需要掌握
*/
@Test
public void testMethod() throws Exception {
  Class clazz = Person.class;
  Person p = (Person) clazz.newInstance();
  //1. 获取指定的某个方法
  //  getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
  Method show = clazz.getDeclaredMethod("show", String.class);
  //2. 保证当前方法是可访问的
  show.setAccessible(true);
  //3. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
  //  invoke()的返回值即为对应类中调用的方法的返回值
  Object returnValue = show.invoke(p, "CHN");    // String nation = p.show("CHN");
  System.out.println(returnValue);
  System.out.println("*************如何调用静态方法*****************");
  // private static void showDesc()
  Method showDesc = clazz.getDeclaredMethod("showDesc");
  showDesc.setAccessible(true);
  // 如果调用的运行时类中的方法没有返回值，则此invoke()返回null
  Object returnVal = showDesc.invoke(null);
  // Object returnVal = showDesc.invoke(Person.class);
  System.out.println(returnVal);
}

调用指定的构造器

/*
  如何调用运行时类中的指定的构造器，不常用，一般是空参构造器
*/
@Test
public void testConstructor() throws Exception {
  Class clazz = Person.class;
  // private Person(String name)
  // 1.获取指定的构造器
  // getDeclaredConstructor():参数：指明构造器的参数列表
  Constructor constructor = clazz.getDeclaredConstructor(String.class);
  // 2.保证此构造器是可访问的
  constructor.setAccessible(true);
  // 3.调用此构造器创建运行时类的对象
  Person per = (Person) constructor.newInstance("Tom");
  System.out.println(per);
}

反射的应用