java反射调用,java反射调用方法

本文目录一览：

• 1、JAVA反射中通过Class.forname()如何带参数的方法怎么赋值和调用呀？
• 2、java 反射机制的几个调用方法
• 3、java反射机制怎样调用类的私有方法
• 4、java反射调用方法可以传非基本类型吗？如对象、接口
• 5、如何通过java 反射 调用一个 含有 可变参数的 方法呢 ？？

JAVA反射中通过Class.forname()如何带参数的方法怎么赋值和调用呀？

用Class.forName方法动态加载构造方法带参数的类。

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

public class Cat{

                    private int age;

                    private String name;

                    public void Cat(String name, int age){

                           this.name = name;

                           this.age = age;

                   }

        }

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

 import java.lang.reflect.Constructor;

        publc class LoadCat{

                    private int age;

                    private String name;

                    public void LoadCat(String name, int age){

                           super();

                           this.name = name;

                           this.age = age;

                   }

                   public static void main(String args[ ]){

                             Class clazz = Class.forName(“Cat”);

                             Constructor constructor = clazz.getConstructor(String.class, int.class);

                             LoadCat test = (LoadCat) constructor.newInstance(“test”, 1);

                   }

        }

3、补充：

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

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

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

Class? special = Class.forName(“Calendar.SpecialCalendar”); 

Constructor? special_Calendar = 

special.getConstructor(int.class,int.class,int.class); 

specialCalendar = (SpecialCalendar) 

special_Calendar.newInstance(2011,5,27);

4、方法二：

package com.sanmao10;import java.lang.reflect.Constructor;public class test2 {

    /**

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

     * Constructor

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

     * 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)

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

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

        Class clazz=Class.forName(“com.sanmao10.Person”);//        Person p=(Person)clazz.newInstance();    //通过无参构造创建对象//        p.say();

        Constructor c=clazz.getConstructor(String.class,int.class);//获取有参构造

        Person p=(Person) c.newInstance(“sanmao”,12);    //通过有参构造创建对象

        p.say();

    }

}

java 反射机制的几个调用方法

import java.lang.reflect.Method;

import java.lang.reflect.InvocationTargetException;

/**

* Created by IntelliJ IDEA.

* File: TestRef.java

* User: leizhimin

* Date: 2008-1-28 14:48:44

*/

public class TestRef {

public staticvoid main(String args[]) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {

Foo foo = new Foo(“这个一个Foo对象！”);

Class clazz = foo.getClass();

Method m1 = clazz.getDeclaredMethod(“outInfo”);

Method m2 = clazz.getDeclaredMethod(“setMsg”, String.class);

Method m3 = clazz.getDeclaredMethod(“getMsg”);

m1.invoke(foo);

m2.invoke(foo, “重新设置msg信息！”);

String msg = (String) m3.invoke(foo);

System.out.println(msg);

}

}

class Foo {

private String msg;

public Foo(String msg) {

this.msg = msg;

}

public void setMsg(String msg) {

this.msg = msg;

}

public String getMsg() {

return msg;

}

public void outInfo() {

System.out.println(“这是测试Java反射的测试类”);

}

}

java反射机制怎样调用类的私有方法

为了一看就懂，请看下面的示例（假设调用 MyTest类的私有方法 privateMethod()）：

public class ReflectionTest {

  public static void setObjectColor(Object obj) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAcces***ception, InvocationTargetException{   // 核心代码加粗

    Class cls = obj.getClass();

    //获得类的私有方法

    Method method = cls.getDeclaredMethod(“privateMethod”, null);

    method.setAccessible(true); //没有设置就会报错

    //调用该方法

    method.invoke(obj, null);

  }

  public static void main(String args[]) throws SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAcces***ception, InvocationTargetException{

    setObjectColor(new MyTest());

  }

}

 //测试类

class MyTest{

  public void setMyTest(){

    System.out.println(“setMyTest”);

  }

  /**

   类的私有方法

   **/

  private void privateMethod(){

    System.out.println(“调用了 private Method”);

  }

}

java反射调用方法可以传非基本类型吗？如对象、接口

可以的，参数类型是没有限制的。通过以下代码可以证明。

接口：

public interface MyInterface {

    void print();

}

实现类：

public class MyInterfaceImpl implements MyInterface {

    @Override

    public void print() {

        System.out.println(“interfaceImpl”);

    }

}

通过反射调用方法：

import java.lang.reflect.Method;

public class Test {

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

        Test instance = Test.class.newInstance();

        Method method = Test.class.getDeclaredMethod(“test”, MyInterface.class);

        MyInterface myInterface = new MyInterfaceImpl();

        method.invoke(instance, myInterface);

    }

    public void test(MyInterface myInterface) {

        myInterface.print();

    }

}

如何通过java 反射 调用一个 含有 可变参数的 方法呢 ？？

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

public class Reflect {

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

        Class? clazz = Single.class;

        Single single = (Single) clazz.newInstance();

        ListString list = new ArrayListString(){

            private static final long serialVersionUID = 1L;

            {

                add(“fuck”);

                add(“ni”);

                add(“mei”);

            }

        };

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

        /* 1 */

        Method method = clazz.getDeclaredMethod(“method”, Array.newInstance(Object.class, 0).getClass());

        /* 2 */

        method = clazz.getDeclaredMethod(“method”, (new Object[0]).getClass());

        //初始化参数

        /* 1 */

        Object objs = Array.newInstance(Object.class, 2);

        Array.set(objs, 0, list);

        Array.set(objs, 1, “23”);

        method.invoke(single, objs);

        /* 2 */

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

        method.invoke(single, new Object[]{ objects });

    }

}

class Single {

    public void method(Object… objs) {

        System.out.println(Arrays.deepToString(objs));

    }

}

结果:

[[fuck, ni, mei], 23]

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