Java反射基础应用

类定义：

package test;

public class Car {
private int year;
private String name;
private float price;
/**
* 无参构造器
*/
public Car() {
super();
}
/**
* 一个参数的构造器
* @param name
*/
public Car(String name){
super();
this.name = name;
}
/**
* 多个参数的构造器
* @param year
* @param name
* @param price
*/
public Car(int year, String name, float price) {
super();
this.year = year;
this.name = name;
this.price = price;
}

@Override
public String toString() {
return "Car [year=" + year + ", name=" + name + ", price=" + price
+ "]";
}

/**
* 私有方法
* @return
*/
private void testPrivate(){

}
/**
* protected方法
* @return
*/
protected void testProtect(){

}
public void testInvoke(int i,String str){
System.out.println("测试testInvoke成功:"+i+","+str);
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}

}

反射应用：

package test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
* 反射
* @author Administrator
*
*/
public class Invoke {
public static void main(String[] args) throws Exception {
System.out.println("*********无参构造器*********");
Car car = (Car)noParaCreateInstance(Car.class);
car.setName("maibahe");
System.out.println(car);

System.out.println("*********一个参数构造器*********");
Car car2 = (Car)createInstanceByPara(Car.class,"benchi");
System.out.println(car2.toString());

System.out.println("*********多个个参数构造器*********");
Car car3 = (Car)createInstanceByParas(Car.class, 5, "kaidilake", (float) 56.70);
System.out.println(car3.toString());

System.out.println("***********通过反射的方式获取方法*************");
invoke1(car3);

System.out.println("***********通过反射的方式获取方法的另一种方式*************");
invoke2(Car.class);

System.out.println("***********通过反射的方式调用方法*************");
invoke3(car3);

System.out.println("***********直接通过已知方法名以反射的方式获取方法，再以反射的方式调用方法*************");
invoke4(car3);

System.out.println("***********通过反射的方式获取属性名*************");
invokeField(car3);
}
/**
* 对于无参的构造器通过反射的方式获取实例
* @param clazz
* @return
* @throws Exception
*/
public static Object noParaCreateInstance(Class clazz) throws Exception{
Object object = clazz.newInstance();
return object;
}
/**
* 有一个参数的构造器通过反射的方式获取实例
* @param clazz
* @param name
* @return
* @throws Exception
*/
public static Object createInstanceByPara(Class clazz,String name) throws Exception{
Constructor con = clazz.getConstructor(String.class);
Object object = con.newInstance(name);
return object;
}
/**
* 多个参数的构造器通过反射方式获取实例，并且参数的顺序也要和构造器的参数的顺序一致
* @param clazz
* @param year
* @param name
* @param price
* @return
* @throws Exception
*/
public static Object createInstanceByParas(Class clazz,int year,String name,float price) throws Exception{
Constructor con = clazz.getConstructor(int.class,String.class,float.class);
Object object = con.newInstance(year,name,price);
return object;
}
/**
* 通过反射的方式获取方法
* @param obj
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws IllegalArgumentException
*/
public static void invoke1(Object obj) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
//获取当前类(不包括父类)的所有方法(包括private方法和protected方法)
Method[] methods = obj.getClass().getDeclaredMethods();
//获取当前类以及其父类的所有方法(不包括private方法和protected方法)
methods = obj.getClass().getMethods();
for(Method m:methods){
System.out.println(m.getName());
//			if("testInvoke".equals(m.getName())){
//				m.invoke(obj, null);
//			}
}
}
/**
* 通过反射的方式获取方法的另一种方式，直接传递一个.class参数
* @param clazz
*/
public static void invoke2(Class clazz){
//获取当前类(不包括父类)的所有方法(包括private方法和protected方法)
Method[] methods = clazz.getDeclaredMethods();
//获取当前类以及其父类的所有方法(不包括private方法和protected方法)
methods = clazz.getMethods();
for(Method m:methods){
System.out.println(m.getName());
}
}
/**
* 通过反射的方式调用方法
* @param obj
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static void invoke3(Object obj) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
//获取当前类(不包括父类)的所有方法(包括private方法和protected方法)
Method[] methods = obj.getClass().getDeclaredMethods();
//获取当前类以及其父类的所有方法(不包括private方法和protected方法)
methods = obj.getClass().getMethods();
for(Method m:methods){
if("testInvoke".equals(m.getName())){
//通过反射的方式调用方法：m就是方法，即：方法.invoke(obj,para)，方法调用方法自己
//				m.invoke(obj, null);如果方法无参数则为null
m.invoke(obj, 3,"good");//如果方法有多个参数，则用逗号隔开
}
}
}
/**
* 直接通过已知方法名以反射的方式获取方法，再以反射的方式调用方法
* @param obj
* @throws SecurityException
* @throws NoSuchMethodException
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static void invoke4(Object obj) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
Method method = obj.getClass().getMethod("testInvoke", int.class,String.class);//若方法无参数则第二个参数用null代替
method.invoke(obj, 5,"fuck");
}
/**
* 以反射的方式获取属性
* @param obj
* @throws Exception
*/
public static void invokeField(Object obj) throws Exception{
//获取当前类(不包括父类)的所有属性(包括private属性和protected属性)
Field[] fields = obj.getClass().getDeclaredFields();
//获取当前类以及其父类的所有属性(不包括private属性和protected属性)
fields = obj.getClass().getFields();
for(Field f:fields){
System.out.println(f.getName());
}
}
/**
* 通过反射的方式获取类似于"@Override"这类东西
* @param obj
* @throws Exception
*/
public static void invokeAnnotation(Object obj) throws Exception{
Annotation[] annotations = obj.getClass().getAnnotations();
}
}