本文目录一览：
- 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]]
