java高级特效反射

一 、什么叫反射
1、 在程序运行时动态解析类的内部信息（注解，属性，方法），
所以反射的前提就是：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）
2、获取类信息的三种方法

（1）Class      class                         对象
  	Field        private Xxx valName=        “name”
    访问修饰符  private/default/protected/public
	数据类型    boolean/char/../xxx
    属性名称    valName 
  Method     public xxx methodName(..){...}
      访问修饰符  private/default/protected/public
      返回类型    void/boolean/char/../xxx
      方法名称    mothodName
      参数列表   Parameter
  Constructor  public ClassName(...)(..)
      访问修饰符
      参数列表     Parameter
（2）三种方法
	 1、 Class c = ToolKit.class;          // 通过已知类名获取类型信息
	 2、ToolKit tl = new ToolKit();
		 Class  = tl.getClass();         //通过对象获取类型信息
	 3、Class = Class.forName(String class FullPath);  //通过全包路径字符串获取类信息

3、获取类名
（1）String fullPathName = c.getName(); //获取类全包路径
（2）String simpleName = c.getSimpleName(): //获取类的简名
4、反射创建对象
（1）通过无参构造创建对象 T t = (T)c.newinstance();
（2）获取当前类中的构造方法
Constructor cons = c.gerConstructor(Class<?>…ParameterTypes);
T t = (T) cons.newInstance(Object…parameters);
5、获取当前类中的自定义属性
(1)Filed[] fs = c.getDeclaredField(); //获取当前类中的所有属性
(2)Filed fs=c.gerField(); //获取所有当前类以及父类中的公共属性
(3)Field[] fs =…
int modifiedNum = f.getModifies(); //获取属性访问修饰整数
2：pricate o:default 4:protected 1 pubilc
class c = f.getType(); //获取属性的类型信息
String typeName = c.getName(); //获取属性的类型名称
String fieldName = f.getName();// 获取属性的名称

    f.setAcessible(boolean visible);   //设置属性的可见性
    F.set(Xxx,xxx  value);          //给t对象的f属性赋值
    E value = .get(T  t);            // 获取t对象f属性的值

6、获取当前类中的自定义方法
（1）Method[] ms = c.getDeclaredMethod(); //获取当前类中所有方法
（2）Method[]ms=c.getDeclaredMethods(); //获取当前类和父类中的所有公共方法
（3）Method m =…
String methodName = m.getName(); //获取方法名称
Class c = m.getReturnType() //获取方法返回类型
String returnType = c.getName() //获取方法返回类型名称
Class[]parameterTypes = c.getParameter(Tpyes); //获取方法所有参数类型
M.setAccessible(boolean visible); // 设置方法的可见性
E val = (E)m.invoke(T target, object…, paraans); // 调用方法

例如：`package reflect01;

import java.lang.reflect.Method;
import java.util.*;

public class ReflectUtil {
private static final long BASIC=0x20200615001L;
private static final long REFERENCE=0x20200615002L;

private static Map<Long,Set<String>> types = new HashMap<>(2);

static {
    HashSet<String>  basic = new HashSet<>();
    HashSet<String>  reference = new HashSet<>();
    basic.addAll(Arrays.asList("char","byte","int","short","long",
            "float","double","boolean"));
    reference.addAll(Arrays.asList("java.lang.String","java.lang.Byte",
            "java.lang.Short","java.lang.Integer","java.lang.Long","java.lang.Float",
            "java.lang.Double","java.lang.BigInteger","java.math.BigDecimal"));
    types.put(BASIC,basic);
    types.put(REFERENCE,reference);
}

/**
 * @param typeName 类型名称
 * @return 1 基本类型 0 基本类型保证类型 -1 非基本类型
 */
private static int isBasic(String typeName){
    return types.get(BASIC).contains(typeName)?1:types.get(REFERENCE).contains(typeName)?0:1;
}

/**
 * 将字符串
 * @param c
 * @param value
 * @return
 * @throws Exception
 */
private static Object parseBaiseRef(Class c,String value) throws Exception {
    return c.getConstructor(String.class).newInstance(value);
}

/**
 * 将字符串转化为type指定类型的基本类型值
 * @param type
 * @param value  需要转化的字符串
 * @return Object
 */
private static Object parseBasic(String type,String value){
    Object v =null;
    switch (type){
        case "char":
            v=value.charAt(0);
            break;
        case "byte":
            v=Byte.parseByte(value);
            break;
        case "short":
            v=Short.parseShort(value);
            break;
        case "int":
            v=Integer.parseInt(value);
            break;
        case "long":
            v=Long.parseLong(value);
            break;
        case "boolean":
            v=Boolean.parseBoolean(value);
            break;
        case "float":
            v=Float.parseFloat(value);
            break;
        case "double":
            v=Double.parseDouble(value);
            break;


    }
    return v;
}

private static void nullCheck(Object...args){
    if(null!=args){
        for (Object arg :args){
            if(null==arg){
                throw new NullPointerException("空指针异常");
            }
        }
    }
}

/**
 * 获取方法带有
 * @param method
 * @return
 */
private static Class getMPT(Method method){
    return method.getParameterTypes()[0];
}

public static void set(Object obj,Method method,String val) throws Exception{
    Class mpt = getMPT(method);
    int type = isBasic(mpt.getName());
    if(-1==type){
            throw new TypeNotPresentException(type+
                    "非基本类型异常",new Throwable());
    }
    method.invoke(obj,1==type?parseBasic(mpt.getName(),val):parseBaiseRef(mpt,val));
}

public static Map<String,Method> parseSet(Class c) throws Exception{
    nullCheck(c);
    Map<String,Method> map = new HashMap<>();
    for (Method method : c.getMethods()) {
        String mn  =method.getName();
        if(mn.startsWith("set")){
            mn = mn.substring(3);
            mn = mn.substring(0,1).toLowerCase()+mn.substring(1);
            map.put(mn,method);
        }
    }
    return map;
}

}
`