在java运行环境中,对任意一个类能否知道这个类有哪一些方法?对于任意一个对象,能否调用他的任意一个方法?答案是肯定的。这种动态获取类信息以及动态调用对象的方法的功能来自java的反射机制,在java.lang.reflect包下有三个类Field、Method、Constructor。分别用来描述类的域、方法和构造器。
java反射机制主要提供一下功能
1、在运行时判断任意一个对象所属的类。
2、在运行时构造任意一个类的对象。
3、在运行时判断任意一个类所具有的成员变量和方法。
4、在运行时调用任意一个对象的方法。
Reflection 是java被视为动态语言(准动态语言)的一个关键性质。这个机制允许程序在运行时透过Reflection APIs去获取任何一个已知名称的class的内部信息,包括其modifiers(public,static等等)、superclass(Object)、实现interface(Serializable),也包括fields和methods的所有信息,并可于运行时改变fields内容和methods的所有信息,并可用于运行时改变fields内容或调用methods
尽管java不是动态语言,他却有一个动态机制:reflection,在Java身上指的是我们可以运行时加载、探知、适应编译期间完全未知的classes。换句话说,java程序可以加载一个运行时在得知名称的class,知道其完整的构造(不包括methods定义),并生成对象实体、或对其fields设置、或唤起其methods。这种看透class的能力。
在java中,无论生成某个类的多少对象,这些对象都会应与同一个对象。
import java.lang.reflect.Method;
public class DumpMethods {
public static void main(String[]args)throws Exception{
Class<?> classType=Class.forName("java.lang.String");
Method[] methods=classType.getDeclaredMethods();
for ( Method method:methods){
System.out.println(method);
//可以得到String类里面的所有方法
}
}
}
import java.lang.reflect.Method;
public class InvokeTester {
public int add(int param1,int param2){
return param1+param2;
}
public String echo(String message)
{
return "helle "+message;
}
public static void main(String[]args)throws Exception{
// 获取对象的第一种方式
// InvokeTester test=new InvokeTester();
// System.out.println(test.add(1,2));
// System.out.println(test.echo("tom"));
//获取对象的第二种方式
Class<?> classType=InvokeTester.class;
Object invokeTest=classType.newInstance();
//判断是否实例化
System.out.println(invokeTest instanceof InvokeTester);
Method method=classType.getMethod("add",new Class[]{int.class,int.class});
Object result=method.invoke(invokeTest,new Object[]{1,2});
System.out.println((Integer) result);
//第二种方法
Method getmethod=classType.getMethod("echo",new Class[] {String.class});
Object result2= getmethod.invoke(invokeTest,new Object[]{"tom"});
System.out.println((String)result2);
}
}
要想使用反射,首先需要获得待处理类或对象所对应的Class对象。
获取某个类或某个对象的Class对象的三种方式:
1、使用Class类的静态方法:forName:Class.forName。
2、使用 .class语法。
3、使用对象的getClass方法:String s=“aa”;Class<?> clss=s.getClass;
若想通过类的不带参数的构造方法来生成对象,两种方式:
1、先获得Class的对象,然后通过Class对象newInstance()直接生成;Class<?> classType=String.class;Object obj=classType.newInstance();
2、先获得Class对象,然后通过该对象获得对应的Constructor对象,在通过Constructor对象的newInstance方法生成:Class<?> classType=Customew.class; Constructor cons=class.Type.getConstructor(new Class[]{}); Object obj=cons.newInstance(new Object[]{});
若想通过类带参数的构造方法生成对象,有一种方法
Class<?> classType=Customew.class;
Constructor cons=class.Type.getConstructor(new Class[]{String.class,int.class});
Object obj=cons.newInstance(new Object[]{“hello”,4});
package reflect;
import java.lang.reflect.Field;
public class PrivateTest {
private String name="zhangsan";
public String getName(){
return name;
}
}
class Private{
public static void main(String []args) throws Exception {
PrivateTest p=new PrivateTest();
Class<?> classType=p.getClass();
Field field=classType.getDeclaredField("name");
field.setAccessible(true);
field.set(p,"lishi");
System.out.println(p.getName());
}
}
package reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class PrivateTest {
private String getName(String name){
return name;
}
}
class Private{
public static void main(String []args) throws Exception {
PrivateTest p=new PrivateTest();
Class<?> c=p.getClass();
Method method=c.getDeclaredMethod("getName",new Class[]{String.class});
method.setAccessible(true);
String str=(String)method.invoke(p,new Object[]{"zhangsan"});
System.out.println(str);
}