java反射机制学习总结！

    正常情况下必须先有类，再有对象，反射是：通过对象，找到其所在的类。  
    ● 实例化Class的三种方法：  
    1.getClass()  
        public static void main(String[] args) {  
            Person p = new Person();  
            Class<?> c = p.getClass();//取得Class对象  
            System.out.println(c.getName());  
        }  
    2.类.Class名称  
        public static void main(String[] args) {  
            Class<?> c = Person.class;//取得Class对象  
            System.out.println(c.getName());  
        }  
    3.Class.forName()  
        public static void main(String[] args)throws Exception {  
            Class<?> c = null;  
                c = Class.forName("classdemo.instance.Person");//取得Class对象  
                System.out.println(c.getName());  
        }  
      
    ● 通过Class类实例化对象  
    1、实例化无惨构造的类  
    正常是通过new关键字进行实例化，现在通过Class完成。  
    (1).通过包.类名称实例化Class对象  
    (2).通过Class类中的public T newInstance()  
        public static void main(String[] args)throws Exception {  
            Class<?> c = null;  
                c = Class.forName("classinstance2.Person");//取得Class对象            
                Person p =(Person) c.newInstance();//实例化Person对象          
                System.out.println(p);  
        }  
    2、实例化指定构造的类  
    如果没有无惨构造，必须通过指定的构造方法，并向其传递制定  
    的参数才可以进行实例化。  
    (1).取得一个类的所有构造方法：public Constructor<?>[] getConstructors()  
    (2).通过Construct类的：public T newInstance(Object... initargs)  
        参数最多的是第一构造，参数最少的是最后一个构造。  
        public static void main(String[] args)throws Exception{  
            Class<?> c = null;  
            Person p = null;  
                c = Class.forName("classinstance3.Person");//取得Class对象  
                Constructor<?>[] con = c.getConstructors();//取得全部构造  
                p = (Person) con[0].newInstance("MLKJ",20);//实例化Person对象  
                System.out.println(p);  
        }  
      
    ● 通过Clas类取得完整结构  
    1.取得继承的父类：public Class<? super T> getSuperclass()  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("classDemo1.Person");  
            Class<?> su = c.getSuperclass();//得到继承的父类  
            System.out.println(su.getName());//输出继承的父类  
        }  
    2.取得实现的全部接口：public Class<?>[] getInterfaces()  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("classDemo1.Person");  
            Class<?> inter[] = c.getInterfaces();//得到全部的接口  
            for (int i = 0; i < inter.length; i++) {  
                System.out.println(inter[i].getName());//输出实现的接口  
            }  
        }  
    接口本身就是一个特殊的类，所以以Class对象数组形式返回  
    3.取得一个类的全部构造方法：public Constructor<?>[] getConstructors()  
    然后通过Constructor类中的以下方法进行拼凑：  
        |-取得访问修饰符：public int getModifiers()  
        |-取得参数的全部类型：public Class<?>[] getParameterTypes()  
    使用Modifer的类进行访问修饰符还原：public static String toString(int mod)  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("classDemo1.Person");  
            Constructor<?> con[] = c.getConstructors();//得到全部构造方法  
            for (int i = 0; i < con.length; i++) {  
                int mod = con[i].getModifiers();//得到访问修饰符  
                String str = Modifier.toString(mod);//还原修饰符  
                Class<?>[] par = con[i].getParameterTypes();//得到参数类型  
                System.out.print(str+" ");//输出访问修饰符  
                System.out.print(con[i].getName()+"(");//得到构造方法名称  
                for (int j = 0; j < par.length; j++) {//遍历参数类型  
                    System.out.print(par[j].getName()+" arg-"+j);//输出参数类型  
                    if(j<par.length-1){//加，号得算法  
                        System.out.print(",");  
                    }  
                      
                }  
                System.out.println(")");  
            }  
        }  
    4.得到一个类的全部方法：public Method[] getMethods()  
    然后通过Method类的以下方法进行拼凑：  
        |-取得方法的返回值类型：public Class<?> getReturnType()  
        |-取得全部参数类型：public Class<?>[] getParameterTypes()  
        |-取得方法的抛出异常：public Class<?>[] getExceptionTypes()  
        public static void main(String[] args) throws Exception {  
            Class<?> c = Class.forName("classDemo1.Person");//实例化Class对象  
            Method[] me = c.getMethods();//取得全部方法  
            for (int i = 0; i < me.length; i++) {  
                String str = Modifier.toString(me[i].getModifiers());// 取得访问权限  
                Class<?> ret = me[i].getReturnType();//取得每个方法的返回值类型  
                String metName = me[i].getName();//取得方法名称  
                Class<?>[] par = me[i].getParameterTypes();//取得参数类型  
                Class<?>[] ex = me[i].getExceptionTypes();//取得所有抛出异常  
                System.out.print(str + " ");//输出访问修饰符  
                System.out.print(ret + " ");//输出返回值类型  
                System.out.print(metName + "(");//输出方法名称  
                for(int j=0;j<par.length;j++){//遍历参数类型  
                    System.out.print(par[j].getName()+" args-"+j);  
                    if(j<par.length-1){  
                        System.out.print(",");  
                    }  
                }  
                System.out.print(")");  
                if(ex.length>0){//如果有异常则打印throws  
                    System.out.print("throws ");  
                }  
                for(int j=0;j<ex.length;j++){//然后输出所有异常  
                    System.out.print(ex[j].getName());  
                    if(j<par.length-1){  
                        System.out.print(",");  
                    }  
                }  
                System.out.println();  
            }  
        }  
    5.取得一个类的全部属性  
        |-得到继承而来的公告属性：public Field[] getFields()throws SecurityException  
        |-得到自定义的属性：public Field[] getDeclaredFields()throws SecurityException  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("classDemo1.Person");  
            {  
                Field[] f = c.getFields();  
                for (int i = 0; i < f.length; i++) {  
                    String str = Modifier.toString(f[i].getModifiers());  
                    System.out.print(str+" ");  
                    System.out.println(f[i].getType().getName());  
                }  
            }  
            {  
                Field[] f = c.getDeclaredFields();  
                for (int i = 0; i < f.length; i++) {  
                    String str = Modifier.toString(f[i].getModifiers());  
                    System.out.print(str+" ");  
                    System.out.println(f[i].getType().getName());  
                }  
            }  
        }  
    ● 反射的进一步应用  
    1.通过反射调用类中的方法  
    正常情况下是通过对象.方法()，进行调用，现在通过反射机制完成。  
    1.Class类中使用public Method getMethod(String name,Class<?>... parameterTypes)  
    方法取得要调用方法的Method对象。  
    2.取得Method对象之后，用Method类中的：public Object invoke(Object obj, Object... args)  
    方法进行调用。  
    1.调用类中没有参数，没有返回值的方法  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("InvokeMethodDemo.Person");//取得Class实例化对象  
            Method m = c.getMethod("AA");//取得Method对象  
            m.invoke(c.newInstance());//调用方法  
        }  
    2.调用类中没有参数，有返回值的方法  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("InvokeMethodDemo.Person");//取得Class实例化对象  
            Method m = c.getMethod("getInfo");//取得Method对象  
            String str = (String)m.invoke(c.newInstance());//调用方法  
            System.out.println(str);  
        }  
    3.调用类中有参数，有返回值的方法  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("InvokeMethodDemo.Person");//取得Class实例化对象  
            Method m = c.getMethod("say",String.class,String.class);//取得Method对象  
            String str = (String)m.invoke(c.newInstance(),"AA","love");//调用方法  
            System.out.println(str);  
        }  
    4.调用get跟set方法  
        import java.lang.reflect.Method;  
    public class InvokeGetSet {  
        public static void main(String[] args)throws Exception {  
            Class<?> c = Class.forName("InvokeMethodDemo.Person");  
            Object o = c.newInstance();  
            set("name","AA",o,String.class);  
            set("age",30,o,int.class);  
            get("name",o);  
            get("age",o);  
        }  
        /** 
         * @param name   属性名称 
         * @param value  属性值 
         * @param obj    要操作的对象 
         */  
        public static void set(String name,Object value,Object obj,Class<?> type)throws Exception{  
            Method met = obj.getClass().getMethod("set"+initStr(name), type);  
            met.invoke(obj, value);  
        }  
        public static void get(String name,Object obj)throws Exception{  
            Method met = obj.getClass().getMethod("get"+initStr(name));  
            Object value = met.invoke(obj);  
            System.out.println(value);  
        }  
        public static String initStr(String name){  
            StringBuffer sb = new StringBuffer();  
            sb.append(name.substring(0, 1).toUpperCase()).append(name.substring(1));  
            return sb.toString();  
        }  
    }