java语言基础入门——反射机制实例

1、什么是反射呢？反射可以理解为在程序运行时获取对象类型信息的操作。它允许动态的发现和绑定类、方法、字段，甚至由其他语言产生的元素。运用反射可以做到列举对象所对应的类的详细信息，如访问修饰符，包名，类名，继承的父类和接口信息，以及类内部的所有成员变量，构造函数，成员函数，函数的修饰符，返回值，参数等信息，甚至还可以利用反射来创建对象，访问成员变量和函数。可以这么说，反射窥探到类的所有信息。

2、反射所需的类。反射很强大，但它用到的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。

Class类：Class类的实例是表示正在运行的Java应用程序中的类和接口。可以这么理解，一个普通类是Class类的一个对象。

Filed类：提供有关接口或类的属性信息，以及对他的访问权限修饰符。反射的字段可能是一个类或接口的属性或实例属性。也就是说Filed用来反射类中的成员变量信息。

Constructor类：提供类的单个构造方法的信息以及对他的访问权限修饰符。也就是说Constructor用来反射类中的构造方法的信息。

Method类：提供关于类或接口上单独某个方法的信息，包括抽象方法，可以得到方法的访问修饰符，返回值类型，参数类型等信息。也就是说method类用来反射类的除构造方法以外的方法信息。

Array类：提供了动态创建数组和访问的数组的静态方法。该类的所有方法都为静态方法。

下面是反射操作的例子，包括了得到类的信息，成员变量，构造方法，成员方法；创建对象，调用方法，得到成员变量的值的操作。package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import product.Producter;

class Book{
private int id;
protected String name;
public double price;
String type;
public Book() {
this(10001,"新华字典",30.3,"工具书");
}
public Book(int id,String name,double price,String type){
this.id=id;
this.name=name;
this.price=price;
this.type=type;
}
private Book(int id) {
this(10001,"新华字典",30.3,"工具书");
this.setId(id);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
private void setAll(int id,String name,double price,String type) {
this.setId(id);
this.setName(name);
this.setPrice(price);
this.setType(type);
}
public String toString(){
return "书名为："+name+" 编码为："+id+" 类型为："+type+" 价格为："+price;
}
}
public class ClassDemo {

/**
* 三种方式可以获得Class对象的方式
*/
public static void getClassObject() {
//调用Object类的getClass()方法类获得Class对象，这是最常用的获得Class对象的方法
Book book1=new Book();
System.out.println(book1.getClass()); //显示形式：class 包名.类名

//使用Class类的forName()静态方法获得与字符串参数相对应的Class对象
try {
//Class class1=Class.forName("java.lang.String");
Class class1=Class.forName("reflection.Book");
//字符串必须是类或接口的全限定名，所以带上包名
System.out.println(class1);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

//使用类型名.class获取该类型对应的Class对象
Class class2=Double[].class;
System.out.println(class2);
}

/**
* 获取Class对象的类型信息
*/
public static void getClassInformation(){
Book book2=null;
book2=new Book(321, "笑傲江湖", 44.5, "武侠");
Class class4=book2.getClass();//获取class对象
String packageName = class4.getPackage().getName();//获取类的包名
System.out.println("包名为："+packageName);
String mod =Modifier.toString(class4.getModifiers());//获取类的修饰符
//.getModifiers()返回的是个整数，调用Modifier的toString方法来转化为String类型
System.out.println("类的修饰符为："+mod);
String className=class4.getName();//获取全限定名（数组类型会产生奇怪字符）
System.out.println("类的全限定名称为："+className);
Class superClass = class4.getSuperclass();//获取父类
System.out.println("父类为："+superClass);
Class[] interfaces=class4.getInterfaces();//获取接口
System.out.println("接口为："+interfaces);

}

/**
* 获取Class对象的类的成员变量的信息
*/
public static void getClassmember(){
Book book2=null;
book2=new Book(321, "笑傲江湖", 44.5, "武侠");
Class class4=book2.getClass();//获取class对象
Field [] fields=class4.getDeclaredFields();//获取所有成员变量
Field []fields2=class4.getFields();//获取public修饰的成员变量
System.out.println("所有成员变量为：");
for(Field ff: fields){
String moString=Modifier.toString(ff.getModifiers());//修饰符
Class classType=ff.getType();//数据类型
String name=ff.getName();//字段名
if (classType.isArray()) {//如果是数组类型需要特别处理一下
String arrType=classType.getComponentType().getName()+"[]";
System.out.println(moString+"修饰的"+arrType+"类型的"+name);
}else {
System.out.println(moString+"修饰的"+classType+"类型的"+name);
}
}
System.out.println("其中用public修饰的有：");
for (Field ff:fields2) {
System.out.println(ff.getName());

}
}

/**
* 获取Class对象的类的构造方法的信息
*/
public static void getClassConstructor(){
Book book2=null;
book2=new Book(321, "笑傲江湖", 44.5, "武侠");
Class class4=book2.getClass();//获取class对象
Constructor[] constructors=class4.getConstructors();//获取该Class对象使用所有public修饰的构造方法
Constructor[] constructors2=class4.getDeclaredConstructors();//获取该class对象所对应类的所有构造方法
System.out.println("class4所属类的构造方法的信息为：");
for (Constructor cc: constructors2) {
String name=cc.getName();//获取构造方法名称
String modifier =Modifier.toString(cc.getModifiers());//获取访问修饰符
System.out.print(name+" "+modifier+" (");
Class [] paramTypes=cc.getParameterTypes();//得到方法的参数列表
for (int i = 0; i < paramTypes.length; i++) {
if (i>0) {
System.out.print(",");
}
if (paramTypes[i].isArray()) {//参数类型为数组时
System.out.print(paramTypes[i].getComponentType().getName()+"[]");
//getComponentType()为数组时返回数组的类型，不为数组返回空
}else {
System.out.print(paramTypes[i].getName());
}

}
System.out.println(")");
}

}

/**
* 获取类的成员方法的信息
*/
public static void getClassmethod(){
Book book2=null;
book2=new Book(321, "笑傲江湖", 44.5, "武侠");
Class class4=book2.getClass();//获取class对象
System.out.println("class4对象实例的所属类的成员方法信息为：");
Method[] methods1=class4.getMethods();
//获取Class对象实例对应的类的所有用public修饰的成员方法
Method[] methods=class4.getDeclaredMethods();
//获取Class对象实例的类的所有成员方法
for (Method mm:methods1) {
String modifier=Modifier.toString(mm.getModifiers());//访问修饰符
Class returnType=mm.getReturnType();//返回类型
if (returnType.isArray()) {//如果是数组类型需要特别处理
String arrType= returnType.getComponentType().getName()+"[]";
System.out.print(" "+ modifier+ " "+arrType+" "+mm.getName()+" (");
}else {
System.out.print(" "+ modifier+ " "+returnType+" "+mm.getName()+" (");
}
Class [] paramTypes=mm.getParameterTypes();//得到方法的参数列表
for (int i = 0; i < paramTypes.length; i++) {
if (i>0) {
System.out.print(",");
}
if (paramTypes[i].isArray()) {//参数类型为数组时
System.out.print(paramTypes[i].getComponentType().getName()+"[]");
//getComponentType()为数组时返回数组的类型，不为数组返回空
}else {
System.out.print(paramTypes[i].getName());
}

}
System.out.println(")");
}

}

/**
* 通过反射来创建类的对象—-通过无参数的构造方法
* @param args
*/
public static Object createNoneParameterObject(String className){
Object object=null;
try {
//加载指定名称的类，获取对应的Class对象，然后调用无参数的构造方法创造一个对象
object=Class.forName(className).newInstance();

} catch (InstantiationException | IllegalAccessException
| ClassNotFoundException e) {
e.printStackTrace();
}
return object;
}

/**
* 通过反射来创建类的对象—-通过有参数的构造方法
* 第一步：获取指定类对应的Class对象
* 第二步：通过Class对象获取满足指定参数类型要求的构造方法类对象
* 第三步：调用指定Constructor对象类型的newInstance方法，传入对应的参数值，创建呢对象
* @param args
*/
public static Object createHaveParameterObject(String className) {
Object object=null;
Class class1;
try {
class1 = Class.forName(className);
Constructor constructor=class1.getConstructor(
int.class,java.lang.String.class,double.class,java.lang.String.class);
object=constructor.newInstance(100,"三国演义",33.2,"历史");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (InstantiationException e) {

b5f6
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return object;
}

/**
* 使用反射来调用方法
* 使用反射可以取得指定类的指定方法的对象代表
* 方法的对象代表就是前面介绍的java.lang.reflect.Method类的实例，
* 通过Method类的invode方法可以动态的调用这个方法
* @param args
*/
public static void callMethods(String classNmae) {
try {
Class class1=Class.forName(classNmae);
Book book=(Book)class1.newInstance();//利用无参构造方法创建一个Book对象
//获取名为setName，带一个String的成员方法所对应的对象代表
Method method1=class1.getDeclaredMethod("setName",String.class);
//在book对象上调用setName，并传值给它，返回值为空
Object returnType=method1.invoke(book, "西游记");
System.out.println("通过反射访问setName函数，其返回值为："+returnType);
//获取名为toString不带参数的成员方法对应的参数列表
Method method2=class1.getDeclaredMethod("toString");
method2.setAccessible(true);//取消访问检查
//在book对象上调用toString方法
String string=(String) method2.invoke(book);
System.out.println(string);

} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}

}

/**
* 通过反射访问成员变量的值
* 通过反射可以取得类的成员变量的对象代表，成员变量的对象代表是java.lang.reflect.Field类的实例
* 可以使用它的get和set方法来对成员变量获取或设置它的值
* @param args
*/
public static void getmember(String className) {

try {
Class class1 = Class.forName(className);
Book book=(Book)class1.newInstance();//使用无参构造方法创建对象
//调取私有属性id
Field idfield=class1.getDeclaredField("id");
idfield.setAccessible(true);//取消对本字段的访问检查
idfield.setInt(book, 202);
//将book对象的IDfield成员变量设置为202
System.out.println("设置后的Id为："+idfield.getInt(book));
} catch (ClassNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (InstantiationException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (SecurityException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}

}
public static void main(String[] args) {
ClassDemo.getClassObject();//三种方式可以获得Class对象的方式
ClassDemo.getClassInformation();//获取Class对象的类型信息
ClassDemo.getClassmember();//获取Class对象的类的成员变量的信息
ClassDemo.getClassConstructor();//获取Class对象的类的构造方法的信息
ClassDemo.getClassmethod();//获取类的成员方法的信息
//通过反射来创建类的对象—-通过无参数的构造方法
Book book=(Book)ClassDemo.createNoneParameterObject("reflection.Book");//带上包名
System.out.println("通过反射创建类的对象（无参构造方法）为："+"\n"+book.toString());
//通过反射来创建类的对象—-通过有参数的构造方法
Book book2=(Book)ClassDemo.createHaveParameterObject("reflection.Book");//带上包名
System.out.println("通过反射创建类的对象（有参构造方法）为："+"\n"+book2.toString());
ClassDemo.callMethods("reflection.Book");//通过Method类的invode方法可以动态的调用这个方法
ClassDemo.getmember("reflection.Book");//通过反射访问成员变量的值
}

}