Java反射机制(Reflection)

1、什么是反射机制？

简而言之，java反射机制就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象的方法的功能称为java的反射机制，个人理解就是一个通过一个这样的工具透彻的了解自己哈

在平常的编程中不会用到，but it’s the backbone for most of the Java, J2EE frameworks

Reflection is the process of examining or modifying the runtime behaviour of a class at runtime.

The java.lang.Class class provides many methods that can be used to get metadata, examine and change the runtime behaviour of a class.

Where is it used?

The Reflection API is mainly used in:

• IDE (Integreted Development Environment) e.g. Eclipse, MyEclipse, NetBeans etc.
• Debugger
• Test Tools etc.

2、反射相关的API

<1>java.lang

Class<T>：表示一个正在运行的Java应用程序中的类和接口，是Reflection的起源

The java.lang.Class class performs mainly two tasks:

• provides methods to get the metadata of a class at runtime.
• provides methods to examine and change the runtime behaviour of a class.

Commonly used methods of Class class:

Method	Description
1) public String getName()	returns the class name
2) public static Class forName(String className)throws ClassNotFoundException	loads the class and returns the reference of Class class.
3) public Object newInstance()throws InstantiationException,IllegalAccessException	creates new instance.
4) public boolean isInterface()	checks if it is interface.
5) public boolean isArray()	checks if it is array.
6) public boolean isPrimitive()	checks if it is primitive.
7) public Class getSuperclass()	returns the superclass class reference.
8) public Field[] getDeclaredFields()throws SecurityException	returns the total number of fields of this class.
9) public Method[] getDeclaredMethods()throws SecurityException	returns the total number of methods of this class.
10) public Constructor[] getDeclaredConstructors()throws SecurityException	returns the total number of constructors of this class.
11) public Method getDeclaredMethod(String name,Class[] parameterTypes)throws NoSuchMethodException,SecurityException	returns the method class instance.

<2>java.lang.reflect

Field、Method、Constructor、Array等

Constructor类：

1、Constructor getConstructor(Class[] params)

获得使用特殊的参数类型的公共构造函数

2、Constructor[] getConstructors()

获得类的所有公共构造函数

3、Constructor getDeclaredConstructor(Class[] params)

获得使用特定参数类型的构造函数(不限制访问级别)

4、Constructor[] getDeclaredConstructors()

获得类的所有构造函数(不限制访问级别)

Class 类

生成类的四种方法：使用对象的getClass()；使用static method Class.forName() (最常被使用)；使用.class语法；如果是java的封装类型，使用TYPE语法

对于上述Constructor类和Class 类使用，用代码来说明：

package com.reflect;

public class Person {
    
    private String name;
    private int age;
    
    public Person()
    {
        
    }
    
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    Person(int age)
    {
        this.age = age;
    }
        
    private Person(String name)
    {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + this.getName() + ", age=" + this.getAge() + "]";
    }
    
    
}

package com.reflect;

import java.lang.reflect.Constructor;

public class ConstructorDemo {
    
    public static void main(String[] args)
    {
        try {
            Class<?> c = Class.forName("com.reflect.Person");//此处类名一定要写完整
            //获得类的所有公共构造函数
            System.out.println("所有公共构造函数");
            Constructor[] constructors = c.getConstructors();
            for(int i = 0; i < constructors.length; i++)
            {
                System.out.println(constructors[i].toGenericString());
            }
            
            //获得使用特殊的参数类型的公共构造函数
            System.out.println("所有指定参数公共构造函数");
            //Constructor constru = c.getConstructor(new Class[]{String.class, Integer.class});
            Constructor constru = c.getConstructor(new Class[]{String.class, int.class});
            
            System.out.println(constru.toGenericString());
            
            //
            System.out.println("获得使用特定参数类型的构造函数(不限制访问级别)");
            Constructor constru1 = c.getDeclaredConstructor(new Class[]{String.class});
            System.out.println(constru1.toGenericString());
            //
            System.out.println("获得类的所有构造函数(不限制访问级别)");
            Constructor[] constru2 = c.getDeclaredConstructors();
            for(int i = 0; i < constru2.length; i++)
            {
                System.out.println(constru2[i].toGenericString());
            }
            
            
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }

    
    
}

运行结果：

所有公共构造函数
public com.reflect.Person(java.lang.String,int)
public com.reflect.Person()
所有指定参数公共构造函数
public com.reflect.Person(java.lang.String,int)
获得使用特定参数类型的构造函数(不限制访问级别)
private com.reflect.Person(java.lang.String)
获得类的所有构造函数(不限制访问级别)
private com.reflect.Person(java.lang.String)
com.reflect.Person(int)
public com.reflect.Person(java.lang.String,int)
public com.reflect.Person()

package com.reflect;

public class ClassDemo {
    
    public static void main(String[] args)
    {
        Class<?> c1 = null;
        Class<?> c2 = null;
        Class<?> c3 = null;
        Class<?> c4 = null;
        
        //方式一：使用对象的getClass()
        Person p = new Person();
        c1 = p.getClass();
        
        //方式二：使用static method Class.forName() (最常被使用)
        try {
            c2 = Class.forName("com.reflect.Person");//此处类名一定要写完整
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //方式三：使用.class语法
        c3 = Person.class;
        
        //方式四：如果是java的封装类型，使用TYPE语法
        c4 = Integer.TYPE;
        
        System.out.println(c1.getName());
        System.out.println(c2.getName());
        System.out.println(c3.getName());
        System.out.println(c4.getName());
        
        
    }
}

运行结果：

com.reflect.Person
com.reflect.Person
com.reflect.Person
int

详细类容参见：1、http://www.javatpoint.com/new-instance()-method

　　　　　　　2、http://www.journaldev.com/1789/java-reflection-tutorial-for-classes-methods-fields-constructors-annotations-and-much-more