JAVA 反射机制详解

Java 反射机制详解：

---

 1.通过一个对象获得该对象完整的包名.类名

Demo demo = new Demo();  //Demo在reflct包下
System.out.println(demo.getClass().getName());  //reflect.Demo

2.创建Class的对象（所有类的对象都是Class的对象）

Class<?> demo1 = null;
Class<?> demo2 = null;
Class<?> demo3 = null;
try {
      //尽量采用这种方式创建class对象
      demo1 = Class.forName("reflect.Demo");
} catch (ClassNotFoundException e) {
      e.printStackTrace();
}
demo2 = new Demo().getClass();
demo3 = Demo.class;

3.通过Class实例化其他对象

      //创建Class对象
       Class<?> demo = null;
        try {
            demo = Class.forName("reflect.Demo");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //通过Class对象创建其他类对象
        Demo demo1 = null;
        try {
            demo1 = (Demo) demo.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        demo1.setAge(25);
        demo1.setName("luotong");
        System.out.println(demo1.getName()+demo1.getAge());

4.通过Class调用其他类中构造函数来创建对象

       //创建Class实例
        Class<?> demo = null;
        try {
            demo = Class.forName("reflect.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //获得构造器
        Constructor<?>[] constructors = demo.getConstructors();

        //利用不同的构造函数创建Person对象
        Person person1 = null;
        Person person2 = null;
        try {
            person1 = (Person) constructors[1].newInstance(12);
            person2 = (Person) constructors[2].newInstance("luotong");
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //输出person对象
        System.out.println(person1.toString());
        System.out.println(person2.toString());

5.获得其他类实现的接口

       //通过Class实例返回一个类实现的接口
        Class<?> demo = null;
        try {
            demo = Class.forName("reflect.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //获得Person实现的接口
        Class<?>[] interfaces = demo.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("person实现的接口"+anInterface.getName());
        }

6.获得其他类的父类

        //取得其他类的父类
        Class<?> demo = null;
        try {
            demo = Class.forName("reflect.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?> superclass = demo.getSuperclass();
        System.out.println(superclass);

7.获得其他类的构造函数

//获得其他类中的全部构造函数
Class<?> demo = null;
try {
     demo = Class.forName("reflect.Person");
} catch (ClassNotFoundException e) {
     e.printStackTrace();
}

Constructor<?>[] constructors = demo.getConstructors();
for (Constructor<?> constructor : constructors) {
     System.out.println(constructor);
 }

8.获得本类的全部属性

//获得本类的全部属性
Class<?> demo = null;
try {
       demo = Class.forName("reflect.Person");
} catch (ClassNotFoundException e) {
       e.printStackTrace();
}
Field[] declaredFields = demo.getDeclaredFields();
System.out.println(declaredFields.length);
for (Field declaredField : declaredFields) {
     //权限修饰符
     int modifiers = declaredField.getModifiers();
     String priv = Modifier.toString(modifiers);
     //属性类型
     Class<?> type = declaredField.getType();
     System.out.println(priv + " " + type.getName() + " " + declaredField.getName() + ";");
}

9.获得本类实现的接口或其父类的属性

//获得父类或者实现的接口的全部属性
Class<?> demo = null;
try {
    demo = Class.forName("reflect.Person");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
//得到父类的属性
Field[] fields = demo.getFields();
for (Field field : fields) {
    //权限修饰符
    int modifiers = field.getModifiers();
    String priv = Modifier.toString(modifiers);
    //属性类型
    Class<?> type = field.getType();
    System.out.println(priv + " " + type.getName() + " " + field.getName());
}

 10.通过反射调用其他类的方法

Class<?> person = null;
try {
      person = Class.forName("reflect.Person");
} catch (ClassNotFoundException e) {
      e.printStackTrace();
}
try {
      //调用Person类的sayChina()方法
      Method sayChina = person.getMethod("sayChina");
      sayChina.invoke(person.newInstance());
      //调用Person类的sayHello()方法
       Method sayHello = person.getMethod("sayHello", String.class, int.class);
       sayHello.invoke(person.newInstance(),"luotong",26);
} catch (Exception e) {
       e.printStackTrace();
}

11.调用其他类的set和get方法

public static void main(String args[]){
        Class<?> demo1 = null;
        Object object = null;
        try {
            demo1 = Class.forName("reflect.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        try {
            object = demo1.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        setter(object,"Sex","男",String.class);
        getter(object,"Sex");
    }

    /**
     * @param obj  //操作的对象
     * @param att  //操作的属性
     */
    public static void getter(Object obj,String att){
        try {
            Method method = obj.getClass().getMethod("get" + att);
            System.out.println(method.invoke(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @param obj  操作的对象
     * @param att  操作的属性
     * @param value 设置的值
     * @param type  参数的类型
     */
    public static void setter(Object obj,String att,String value,Class<?> type){
        try {
            Method method = obj.getClass().getMethod("set" + att, type);
            method.invoke(obj,value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

【运行结果】 男

12.通过反射操作属性

       Class<?> demo2 = null;
        Object obj = null;
        try {
            demo2 = Class.forName("reflect.Person");
            obj = demo2.newInstance();
            Field sex = demo.getDeclaredField("sex");
            sex.setAccessible(true);
            sex.set(obj,"男");
            System.out.println(sex.get(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
【运行结果】 男

13.通过反射取得并修改数组

1 int[] temp = {1,2,3,4};
2 Class<?> aClass = temp.getClass().getComponentType();
System.out.println("数组类型"+aClass.getName());
System.out.println("数组长度"+ Array.getLength(temp));
System.out.println("数组的第一个元素"+Array.get(temp,0));
Array.set(temp,0,100);  //修改数组的第一个元素为100
System.out.println("修改后数组的第一个元素"+Array.get(temp,0));

通过反射修改数组大小（略）

动态代理：

14.如何获得类加载器

public static void main(String args[]){
   Test test = new Test();
   System.out.println(test.getClass().getClassLoader().getClass().getName());
4 }
【结果】 sun.misc.Launcher$AppClassLoader

不容易记住的：

1.

getFields和getDeclaredFields区别：

getFields返回的是声明为public的属性，包括父类中定义的属性。

getDeclaredFields返回的是指定类定义的所有定义的属性，不包括父类的。

2.

getMethods()和getDeclaredMethods()区别：

getMethods返回本类和父类中public的方法。

getDeclaredMethods返回本类中的所有方法，不包括父类中的方法。

3.

getGenericInterface(),返回此对象所表示的类直接实现的接口。

getInterface(),返回此对象所表示的类或接口实现的接口。

4.getSuperClass(),返回某个类直接继承的父类

getGenericSuperClass(),返回某个类直接的具有泛型的父类

package com.guolele.web.controller;

import java.lang.reflect.Constructor;
import java.lang.reflect.Type;

/**
 * Created by Administrator on 2016/6/7.
 */
public class RefConstructor {

    public static void main(String[] args) throws Exception {
        RefConstructor refConstructor = new RefConstructor();
        refConstructor.getConstructor();
    }

    public void getConstructor() throws Exception {
        Class c = null;
        c = Class.forName("java.lang.Long");

        Class cs = java.lang.String.class;

        System.out.println("----------------------------");

        Constructor constructor = c.getConstructor(cs);
        System.out.println("通过参数获取指定Class对象的构造方法(包括父类和实现的接口中的构造方法)");
        System.out.println(constructor.toString());

        Constructor constructor1 = c.getDeclaredConstructor(cs);
        System.out.println("通过参数获取指定Class对象所表示的类或接口的构造方法");
        System.out.println(constructor1.toString());

        Constructor constructor2 = c.getEnclosingConstructor();
        System.out.println("获取本地或匿名Constructor对象，它表示基础类的立即封闭构造方法。");
        if (constructor2 != null) {
            System.out.println(constructor2.toString());
        } else {
            System.out.println("没有获取到任何构造方法");
        }

        Constructor[] constructors = c.getConstructors();
        System.out.println("获取指定Class对象的所有构造方法，包括其父类和实现的接口的构造方法");
        for (Constructor ct : constructors) {
            System.out.println(ct.toString());
        }

        System.out.println("--------------------------");

        Class[] interfaces = c.getInterfaces();
        System.out.println("返回实现的所有接口（包括父类实现的接口）");
        for (Class inf : interfaces) {
            System.out.println(inf.toString());
        }

        Type[] types = c.getGenericInterfaces();
        System.out.println("返回直接实现的接口");
        for (Type t : types) {
            System.out.println(t.toString());
        }

        Class superclass = c.getSuperclass();
        System.out.println("返回间接父类");
        System.out.println(superclass.toString());

        Type genericSuperclass = c.getGenericSuperclass();
        System.out.println("返回其直接继承父类");
        System.out.println(genericSuperclass.toString());

        System.out.println("返回实现的所有接口和父类");
        for (Class aClass : c.getClasses()) {
            System.out.println(aClass.toString());
        }
    }
}

结果：

----------------------------
通过参数获取指定Class对象的构造方法(包括父类和实现的接口中的构造方法)
public java.lang.Long(java.lang.String) throws java.lang.NumberFormatException
通过参数获取指定Class对象所表示的类或接口的构造方法
public java.lang.Long(java.lang.String) throws java.lang.NumberFormatException
获取本地或匿名Constructor对象，它表示基础类的立即封闭构造方法。
没有获取到任何构造方法
获取指定Class对象的所有构造方法，包括其父类和实现的接口的构造方法
public java.lang.Long(long)
public java.lang.Long(java.lang.String) throws java.lang.NumberFormatException
--------------------------
返回实现的所有接口（包括父类实现的接口）
interface java.lang.Comparable
返回直接实现的接口
java.lang.Comparable<java.lang.Long>
返回间接父类
class java.lang.Number
返回其直接继承父类
class java.lang.Number
返回实现的所有接口和父类

Process finished with exit code 0