java 反射获得方法名后怎样判断方法是否含有参数

public static void printMethods(Class cl)

{

Method[] methods =clgetDeclaredMethods();//返回一个包含方法对象的数组

for(Method m : methods)//循环该类的每个方法

{

Class retType = mgetReturnType();//该方法的返回类型，

Sting name = mgetName();//获得方法名

Systenoutprint(" "+ModifiertoString(mgetModifiers());打印方法修饰符

Systemoutprint(" "+retTypegetName() + " " + name +"(");

Class[] paramTypes = mgetParameterTypes();//获得一个方法参数数组（getparameterTypes用于返回一个描述参数类型的Class对象数组）

for(int j = 0 ; j < paramTypeslength ; j++)

{

if ( j > 0 ) Systemoutprint(" , "); //如果有多个参数，中间则用逗号隔开，否则直接打印参数

Systemoutprint (paramTypes[ j ]getName);

}

Systemoutprintln (" );");

}}

//////////getparameterTypes方法用于返回一个描述参数类型的Class对象数组）

用ClassforName方法动态加载构造方法带参数的类。

1、在用ClassforName方法动态加载构造方法带参数的类时,为了将参数传递进去,可以考虑java的反射机制，比如有一个类如下:

public class Cat{

                    private int age;

                    private String name;

                    public void Cat(String name, int age){

                           thisname = name;

                           thisage = age;

                   }

        }

2、如果想用ClassforName方法动态加载这个类,可以用以下类似的代码实现:

 import javalangreflectConstructor;

        publc class LoadCat{

                    private int age;

                    private String name;

                    public void LoadCat(String name, int age){

                           super();

                           thisname = name;

                           thisage = age;

                   }

                   public static void main(String args[ ]){

                             Class clazz = ClassforName("Cat");

                             Constructor constructor = clazzgetConstructor(Stringclass, intclass);

                             LoadCat test = (LoadCat) constructornewInstance("test", 1);

                   }

        }

3、补充：

（1）反射方式调用对象类的由参构造方法！

（2）调用者与被调用者不在同包中（SpecialCalendar位于Calendar包中） 

调用者使用ClassforName()方法，应该显示的注明路径（包名） 

Class<> special = ClassforName("CalendarSpecialCalendar"); 

Constructor<> special_Calendar = 

specialgetConstructor(intclass,intclass,intclass); 

specialCalendar = (SpecialCalendar) 

special_CalendarnewInstance(2011,5,27);

4、方法二：

package comsanmao10;import javalangreflectConstructor;public class test2 {

    /

      ###2705_反射(通过反射获取带参构造方法并使用)

      Constructor

      Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数,

      就不能这样创建了,可以调用Class类的getConstructor(Stringclass,intclass)

      方法获取一个指定的构造函数然后再调用Constructor类的newInstance("张三",20)方法创建对象/

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

        Class clazz=ClassforName("comsanmao10Person");//        Person p=(Person)clazznewInstance();    //通过无参构造创建对象//        psay();

        Constructor c=clazzgetConstructor(Stringclass,intclass);//获取有参构造

        Person p=(Person) cnewInstance("sanmao",12);    //通过有参构造创建对象

        psay();

    }

}

java反射调用可变参数的方法的方式是传入objects参数，如下代码：

public class Reflect {

 

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

        Class<> clazz = Singleclass;

        Single single = (Single) clazznewInstance();

        List<String> list = new ArrayList<String>(){

            private static final long serialVersionUID = 1L;

            {

                add("fuck");

                add("ni");

                add("mei");

            }

        };

         

        //获取method两种方式， 在method中 数组的的空间大小是可以随便写的不一定使用0

        / 1 /

        Method method = clazzgetDeclaredMethod("method", ArraynewInstance(Objectclass, 0)getClass());

        / 2 /

        method = clazzgetDeclaredMethod("method", (new Object[0])getClass());

 

 

         

        //初始化参数

        / 1 /

        Object objs = ArraynewInstance(Objectclass, 2);

        Arrayset(objs, 0, list);

        Arrayset(objs, 1, "23");

        methodinvoke(single, objs);

         

        / 2 /

        Object[] objects = {1, "fuck", list};

        methodinvoke(single, new Object[]{ objects });

    }

}

 

class Single {

    public void method(Object objs) {

        Systemoutprintln(ArraysdeepToString(objs));

    }

}

 

结果:

[[fuck, ni, mei], 23]

[1, fuck, [fuck, ni, mei]]

构造函数和method类似，介绍一下获取method的方法。首先定义个类，里面定义两个方法。

public class TestRflectionFather {

public void showarray(String[] str){

for(String ss:str){

Systemoutprintln(ss);

}

}

public void showarray(){

Systemoutprint("this is no param method");

}

}

获取并运行String[]为参的方法

import javalangreflectMethod;

public class Testmain {

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

Class clazz = ClassforName("TestRflectionFather");

Object fa= clazznewInstance();

Class[] cla = new Class[1];

Object[] obj= new Object[1];

String[] str ={"aaa","bbb","ccc"};

cla[0]=String[]class;

Method me=clazzgetMethod("showarray", cla);

obj[0]=str;

meinvoke(fa, obj);

}

}

获取并运行无参的方法

import javalangreflectMethod;

public class Testmain {

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

Class clazz = ClassforName("TestRflectionFather");

Object fa= clazznewInstance();

Method me=clazzgetMethod("showarray");

meinvoke(fa);

}

}

ClassgetDeclaredMethod()

是获取这个类中所有的方法，返回的是Method[]

如果有参数，第1个是方法名称，第2个是该方法的所有参数数组，这样返回的是Method这个对象

Methodinvoke()

传入调用方法的类，另一个是调用这个方法所需要的参数，如果该方法没有参数，可以不填写，在JDK1,4之前，第2个参数是传入一个数组的，但是在jdk15之后，可以不传数组，多个参数用逗号隔开

不知道你听明白没

以上就是关于java 反射获得方法名后怎样判断方法是否含有参数全部的内容，包括:java 反射获得方法名后怎样判断方法是否含有参数、JAVA反射中通过Class.forname()如何带参数的方法怎么赋值和调用呀、如何通过java 反射 调用一个 含有 可变参数的 方法呢 等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！