Java反射快速掌握

一、获取Class对象的方法：

1.对象.getClass()
2.Class.forName(className)
3.类名.class

二、创建一个对象
class.getConstructor.newInstance(arg...)

3、反射包可以分析类的能力：属性、方法、构造器，有对应的类：Field, Method, Constructor。

class对像有相应的get方法，默认返回public修饰的属性、方法、构造器等。
getDeclare方法返回全部，
获取指定属性、方法、构造器之前要先调用其对应的setAccessible（true），才可以访问private域。

4、运行时分析对象，如获取对象的值、设置对象的值等

4、通过反射调用任意方法

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

/**
 * 反射测试
 */
public class ReflectTest {
    String s;

    public static void main(String[] args) {
        //获取Class对象
        getClazzObj();
        //分析对象的属性、方法、构造器
        analysisClazz();
        newInstance(Double.class);

    }

    /**
     * 获取Class对象
     */
    public static void getClazzObj() {
        try {
            //1
            Class strClazz = Class.forName("java.lang.Double");
            //2
            Class strClazz2 = Double.class;
            //3
            Class strClazz3 = Double.valueOf(100.1).getClass();
            System.out.println("Class对象：" + strClazz3.getName());
            System.out.println("3种方法获取是是否是同一个对象：" + (strClazz == strClazz2 && strClazz2 == strClazz3));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 分析类的属性、方法、构造器
     */
    public static void analysisClazz() {
        Class doubleCl = Double.class;
        //1、获取其父类
        Class supCl = doubleCl.getSuperclass();
        //2、获取类的修饰符
        String modifiers = Modifier.toString(doubleCl.getModifiers());
        analysisField(doubleCl);
        analysisMethod(doubleCl);
        analysisConstructor(doubleCl);
    }

    public static void analysisField(Class cl) {
        Field[] fields = cl.getDeclaredFields();
        for (Field f : fields) {
            //类型
            Class type = f.getType();
            //名称
            String name = f.getName();
            //修饰符
            String modifiers = Modifier.toString(f.getModifiers());
            System.out.println("属性：" + modifiers + " " + type + " " + name);
        }
    }

    public static void analysisMethod(Class cl) {
        Method[] methods = cl.getDeclaredMethods();
        for (Method method : methods) {
            //返回类型
            Class retType = method.getReturnType();
            //方法名
            String name = method.getName();
            //修饰符
            String modifiers = Modifier.toString(method.getModifiers());
            //入参
            Class[] params = method.getParameterTypes();
            String paramStr = "(";
            for (Class p : params) {
                paramStr += p.getName() + ", ";
            }
            paramStr += ")";
            System.out.println("方法：" + modifiers + " " + retType + " " + name + paramStr);
        }
    }

    public static void analysisConstructor(Class cl) {
        Constructor[] constructors = cl.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            //1、构造器名称
            String name = constructor.getName();
            //2、构造器修饰符
            String modifiers = Modifier.toString(constructor.getModifiers());
            //3、构造器参数
            Class[] paramType = constructor.getParameterTypes();
            String paramStr = "(";
            for (Class type : paramType) {
                paramStr += type.getName() + ", ";
            }
            paramStr += ")";
            System.out.println("构造器：" + modifiers + " " + name + paramStr);
        }
    }

    public static void newInstance(Class cl) {
        try {
            double d1 = (Double) cl.getConstructor(double.class).newInstance(1000L);
            double d2 = (Double) cl.getConstructor(String.class).newInstance("2000");
            System.out.println("d1=" + d1);
            System.out.println("d2=" + d2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}