java反射机制

在java学习过程中不可避免的接触到反射，反射是什么？都有哪些用处呢？开一篇文章记录一下。

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射的主要功能有：

在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

getName()：获得类的完整名字。

getFields()：获得类的public类型的属性。

getDeclaredFields()：获得类的所有属性。

getMethods()：获得类的public类型的方法。

getDeclaredMethods()：获得类的所有方法。

getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。

getConstructors()：获得类的public类型的构造方法。

getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。

newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

来一个例子：

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

public class CarTest {
    public static void main(String[] args){
        Car car = new Car(2.4f, 1.2f, 1.9f);
        Car car2 = new Car(2.9f, 3.5f, 2.6f);
        try {
            System.out.println(getProperty(car2, "height"));
        } catch (NoSuchFieldException | SecurityException
                | IllegalArgumentException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取某个类对象的属性
     * @param owner
     * @param fieldName
     * @return
     * @throws NoSuchFieldException
     * @throws SecurityException
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     */
    public static Object getProperty(Object owner, String fieldName) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
        Class ownClass = owner.getClass();
        Field field = null;
        try {
            field = ownClass.getField(fieldName);  //获取这个类的属性
        } catch (Exception e) {
            e.printStackTrace();
        }
        Object property = field.get(owner);  //从对象中获取这个属性的值
        return property;
    }
    
    /**
     * 获取类的静态属性
     * @param className
     * @param fieldName
     * @return
     * @throws ClassNotFoundException 
     * @throws SecurityException 
     * @throws NoSuchFieldException 
     * @throws IllegalAccessException 
     * @throws IllegalArgumentException 
     */
    public static Object getstaticProperty(String className, String fieldName) throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
        //通过包名+类名获得类
        Class ownerClass = Class.forName(className);  //注册一个类
        Field field = ownerClass.getField(fieldName);  //获取类的属性
        Object staticProperty = field.get(ownerClass);  //直接从类中获取这个类的静态属性
        return staticProperty;
    }
    
    /**
     * 调用对象的方法
     * @param owner
     * @param methodName
     * @param args
     * @return
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    public static Object invokeMethod(Object owner, String methodName, Object[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        Class ownerClass = owner.getClass();
        Class[] argsClass = new Class[args.length];     
        for (int i = 0, j = args.length; i < j; i++) {   //argsClass是这个方法的参数  
            argsClass[i] = args[i].getClass();     
        }     
        Method method = ownerClass.getMethod(methodName,argsClass);     
        return method.invoke(owner, args);  //调用这个方法，返回Object类型
    }
    
    /**
     * 新建一个实例
     * @param className
     * @param args
     * @return
     * @throws Exception
     */
    public Object newInstance(String className, Object[] args) throws Exception {     
         Class newoneClass = Class.forName(className);     
          
         Class[] argsClass = new Class[args.length];     
          
         for (int i = 0, j = args.length; i < j; i++) {     
             argsClass[i] = args[i].getClass();     
         }     
          
         Constructor cons = newoneClass.getConstructor(argsClass);  //获取这个方法的构造器
          
         return cons.newInstance(args);   //返回构造的对象
          
    }   
    
    
}