java Class中得到构造方法Constructor、方法Method、字段Field

常用方法：

Constructor类用于描述类中的构造方法：

Constructor<T> getConstructor(Class<?>... parameterTypes)

返回该Class对象表示类的指定的public构造方法;

Constructor<?>[] getConstructors()

返回该Class对象表示类的所有public构造方法;

Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

返回该Class对象表示类的指定的构造方法,和访问权限无关;

Constructor<?>[] getDeclaredConstructors()

返回该Class对象表示类的所有构造方法,和访问权限无关;

 

Method类用于描述类中的方法：

Method getMethod(String name, Class<?> ... parameterTypes)

返回该Class对象表示类和其父类的指定的public方法;

Method[] getMethods()： 

返回该Class对象表示类和其父类的所有public方法;

Method getDeclaredMethod(String name, Class<?>... parameterTypes)

返回该Class对象表示类的指定的方法。和访问权限无关，但不包括继承的方法;

Method[] getDeclaredMethods(): 获得类所有的方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法;

 

Eg：

package junereflect624;

 

import java.lang.reflect.Constructor;

 

class Emp{

    private String name;

    private int age;

    private Emp() {

    }

    Emp(String name){

    }

    public Emp(String name,int age){

    }

}

 

public class ConstructorDemo4 {

    public static void main(String[] args) throws Exception {

        //得到所有的构造器（先得到类）

        Class<Emp> c = Emp.class;

        /**

         * Constructor<?>[] getConstructors()

                返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。

         */

        Constructor[] con = c.getConstructors();//前面的修饰符必须是public才可以在这个方法下获取到

        for (Constructor cons : con) {

            System.out.println("c.getConstructors()"+cons);//如果上面的某构造器public去掉，则显示不出

            /**打印

                public junereflect624.Emp(java.lang.String,int)

             */

        }

       

        //得到指定的构造器,也是必须public

        Constructor c1 = c.getConstructor(String.class,int.class);

        System.out.println(c1);//public junereflect624.Emp(java.lang.String,int)

                                     

System.out.println("====================================");

    //现在想获得不受public影响的,getDeclaredConstructors(),暴力反射

       

        con = c.getDeclaredConstructors();

        for (Constructor cons : con) {

                         

System.out.println("c.getDeclaredConstructors()=="+cons);//此时不受修饰符的影响

            /**打印

             *  public junereflect624.Emp()

                public junereflect624.Emp(java.lang.String)

                public junereflect624.Emp(java.lang.String,int)

             */

        }

    }

}

 

 

package junereflect624;

 

import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

 

class AB{

    protected String name;

    protected String id;

}

@Deprecated

public class MethodDemo5 extends AB{

    void show(){}

    public void say(){}

    private int age;

    public char c;

    private boolean b;

    public static void main(String[] args) throws Exception {

        Class<MethodDemo5> c = MethodDemo5.class;

        //获取所有的（包含父类的方法）public修饰的方法

        Method[] m = c.getMethods();

        for (Method method : m) {

            System.out.println(method);

        }

        //总结：4个方法，获取全部，获取特定；不受修饰符影响的全部，不受修饰符影响的特定；（前两个都还是受限制的）

       

        //获取指定的方法

        Method me = c.getMethod("main", String[].class);

        System.out.println("main "+me);//main public static void junereflect624.MethodDemo5.main(java.lang.String[]) throws java.lang.Exception

       

        //访问所有方法，不受访问权限影响

        m = c.getDeclaredMethods();

        for (Method method : m) {

            System.out.println("不受影响的："+method);

        }

       

        me = c.getDeclaredMethod("show");

        System.out.println(me);//void junereflect624.MethodDemo.show()

 

        me = c.getMethod("toString");

        System.out.println(me);//public java.lang.String java.lang.Object.toString()

       

        /**

         * Method[] getDeclaredMethods()

                  返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，

                  包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法,只可以对当前类有效

         */

        /*me = c.getDeclaredMethod("toString");//ERROR,c.getDeclaredMethod()不能得到继承的方法

        System.out.println(me);//public java.lang.String java.lang.Object.toString()

         */

        //得到字段

        Field[] f = c.getFields();

        for (Field field : f) {//只得到了public的

            System.out.println("字段"+field);

        }

       

        //特定字段

        Field fi = c.getField("c");//""里面是名称

        System.out.println(fi);//public char junereflect624.MethodDemo.c

       

        //得到不受限定名限定的全部字段

        f = c.getDeclaredFields();

        for (Field field : f) {//得到不受修饰符限定的字段，但是只对当前类有效

            System.out.println("全部字段："+field);

            /**

             *  全部字段：private int junereflect624.MethodDemo.age

                全部字段：public char junereflect624.MethodDemo.c

                全部字段：private boolean junereflect624.MethodDemo.b

             */

        }

        //注释  Annotation

         Annotation[] a = c.getAnnotations();

         System.out.println(a.length);

         for (Annotation annotation : a) {

            System.out.println(annotation);

        }

         

         //特定注解

         Deprecated d = c.getAnnotation(Deprecated.class);

         System.out.println(d);

    }

}

 

获取当前对象的字段：

package july78javaEnhance;

 

import java.lang.reflect.Field;

 

class Stu{

    public String name;

    public String sex;

    public int age;

   

    public Stu(String name, String sex, int age) {

        super();

        this.name = name;

        this.sex = sex;

        this.age = age;

    }

}

 

public class ReflectDemo6 {

    public static void main(String[] args) throws Exception {

        Stu s = new Stu("刘昭", "男", 12);

       

        Class<Stu> c = Stu.class;

       

        Field f = c.getField("name");

        System.out.println(f.get(s));从哪个对象身上取！此时显示刘昭！

//  修改对象的值

/**

Field f = c.getField("name");

        f.set(s,"章泽天");

System.out.println(f.get(s));//从哪个对象身上取！//此时显示章泽天

*/

    }

}

 

 

我的总结：对于方法，字段，构造方法之类用类获取记住四个：获取全部，获取特定，暴力获取全部，暴力获取特定！

转载于:https://www.cnblogs.com/fanweisheng/p/11136751.html