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]]