浅谈Java反射机制

1.什么是Java反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2.Java反射的作用
我们的类加载器主要完成加载class文件，String.class,Integer.class等提供了一个描述字节码文件的类型Class.通过Class可以动态的获得一个类的信息。

3.实例
注：具体方法请参考java.lang.Class

public class Book {
    private int id;
    private String name;
    private String type;
    public long aLong;

    public long getaLong() {
        return aLong;
    }

    public void setaLong(long aLong) {
        this.aLong = aLong;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {

        System.out.println("获取名字");
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    public String test(String aa,int bb){
        return "调用了多参数:"+aa+"  "+bb;
    }
}

public class Test
{
    public static void main(String[] args) {
        //要想使用反射，首先要获得Class类
        Demo1();  
        System.out.println("================");
        //通过Class类获得构造函数
        Demo2();  
        System.out.println("================");
        //通过Class类获得类的属性
        Demo3();  
        System.out.println("================"); 
        //通过Class类获得类的方法名
        Demo4();  
        System.out.println("================"); 
        //通过Class类调用方法
        Demo5();  
        System.out.println("================"); 
    }
    public void demo1(){
        //获得Class类的三种方法
        Class demo1 = null;
        Class demo2 = null;
        Class demo3 = null;
            Demo6();  
        System.out.println("================"); 
        Demo7();  
        System.out.println("================"); 
        try {
             //forName里面是类的路径
            demo1 = Class.forName("com.reflect.Book");
            System.out.println("对象一："+demo1);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //通过实体类获得
        Book bo = new Book();
        Object ob = bo;
        System.out.println("对象二："+ob.getClass());

        demo3 = Book.class;
        System.out.println("对象三："+demo3);
    }
    public void demo2(){
        /*
        通过调用Class类的newInstance方法(只能调用类的默认构造方法)可以创建类的实例。这样有局限性，我们可以先调用类的Class实例获取类的构造方法，然后在利用反射来创建类的一个实例。
        */
        //调用默认的构造方法
         Class demo3 = Book.class;
         try {
           Book b = (Book) demo3.newInstance();
            System.out.println(b);
         } catch (InstantiationException e) {
            e.printStackTrace();
         } catch (IllegalAccessException e) {
            e.printStackTrace();
         }
        /*
            Constructor[] getDeclaredConstructors()：返回已加载类声明的所有的构造方法的Constructor对象数组。
Constructor  getDeclaredConstructor(Class[] paramTypes)：返回已加载类声明的指定构造方法的Constructor对象，paramTypes指定了参数类型。
Constructor[] getConstructors()：返回已加载类声明的所有的public类型的构造方法的Constructor对象数组。
Constructor  getConstructor(Class[] paramTypes)：返回已加载类声明的指定的public类型的构造方法的Constructor对象，paramTypes指定了参数类型。
        */
     }
    public void demo3(){
        Book book = new Book();
        book.setId(1);
        book.setName("笑面人");
        book.setType("小说");
        Field[] fs = book.getDeclaredFields();//能获取私有属性
        for (Field f:fs){
            System.out.println(f.getName()+"  "+f.getType());
        }

        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
        Field[] fi = book.getFields();//不能获取私有对象
        for (Field f:fi){
            System.out.println(f.getName()+"  "+f.getType());
        }
    }

    public void demo4(){
        Class c1 = Book.class;
        Method[] methods = c1.getDeclaredMethods();
        for (Method m:methods){
            System.out.println("方法名："+m.getName());
            System.out.println("方法修饰符：" + Modifier.toString(m.getModifiers()));
            System.out.println("方法返回值："+m.getReturnType());
            //获得形参的类型
            Class[] classes = m.getParameterTypes();
            for (Class c:classes){
                System.out.println(c.getName());
            }
        }
    }
    public void demo5(){
         Class c = Book.class;
        try {
            //获得无参的方法
            Method m0 = c.getMethod("getName",null);
            //获得一个参数的方法
            Method m = c.getMethod("setName",String.class);
            //获得多个参数的方法
            Class[] classes = {String.class,int.class};
            Method ms = c.getMethod("test",classes);
            try {
                System.out.println( m0.invoke(o1,new Object[0]));
                m.invoke(o1, "西游记");
                Object[] o = {"哈哈",888};
                System.out.println(ms.invoke(o1,o));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}