package 反射;
public class Test反射 {
public static void main(String[] args) {
System.out.println(Runtime.getRuntime().getClass());//class java.lang.Runtime
Test反射 t=new Test反射();
System.out.println(t.getClass());//class 反射.Test反射
}
}
getClass
package 反射;
public class Test反射 {
public static void main(String[] args) {
Test反射 t=new Test反射();
//Class类是反射操作的源头，所有的反射都要从此类开始进行。
Class<?> cls=t.getClass();//第1种Class类实例化方法，用的很少
System.out.println(cls);//class 反射.Test反射
Class<?> cls2=Test反射.class;//第2种Class类实例化方法，用的多,使用领域：Hibernate、Mybatis、Spring
System.out.println(cls2);//class 反射.Test反射
Class<?> cls3=null;
try {
cls3=Class.forName("反射.Test反射");//第3种Class类实例化方法，用的多。此处要写全名，即加上包名，否则报错。
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(cls3);//class 反射.Test反射
}
}
Class类3种实例化方式
package 反射;
class A{
public A(){
System.out.println("调用无参构造实例化对象。");
}
@Override
public String toString() {
return "调用toString()方法。";
}
}
public class Test反射 {
public static void main(String[] args) {
Class<?> cls=null;
try {
cls=Class.forName("反射.A");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Object o=null;
try {
o=cls.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println(o);
/**
* 运行结果：
* 调用无参构造实例化对象。
* 调用toString()方法。
*/
}
}
利用反射进行实例化对象
package 反射; import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException; class A{
private String name;
private int age;
public A(String name,int age){
System.out.println("调用有参构造实例化对象。");
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "调用toString()方法:name="+name+",age="+age;
}
}
public class Test反射 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
Class<?> cls=null;
try {
cls=Class.forName("反射.A");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Object o=null;
try {
Constructor<?> con=cls.getConstructor(String.class,int.class);
o=con.newInstance("张三",18);//从此处可以看出以后定义类的构造方法时最好保留一个无参构造。
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println(o);
/**
* 运行结果：
* 调用有参构造实例化对象。
* 调用toString()方法:name=张三,age=18
*/
}
}
利用反射实例化对象，调用有参构造。
package 反射; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; class Person{
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public class Test反射 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class<?> cls=Class.forName("反射.Person");
Object obj=cls.newInstance();
Method methodSetName=cls.getMethod("setName", String.class);
Method methodGetName=cls.getMethod("getName");
methodSetName.invoke(obj, "张三");
System.out.println(methodGetName.invoke(obj));//张三
}
}
利用反射调用普通方法
package 反射;
import java.lang.reflect.Field;
class Person{
@SuppressWarnings("unused")
private String name;
}
public class Test反射 {
public static void main(String[] args) throws Exception {
Class<?> cls=Class.forName("反射.Person");
Object obj=cls.newInstance();
Field fieldName=cls.getDeclaredField("name");
fieldName.setAccessible(true);//私有属性的存取不建议用引方式，最好还是用setter和getter方法
fieldName.set(obj, "张三");
System.out.println(fieldName.get(obj));//张三
}
}
利用反射存取属性