通过前面的学习，我们知道了反射其实是面向类编程的。
下面我们综合所学的知识，来编写一个使用与所有对象的toString方法。
下面学习两种意义上的toString：
1）将这个类的内容打印出来
/**
* 只输出类的公共信息
* @param object 对象
* @return 该对象的类对象的公共信息
*/
public String toString(Object object) {
// 获得代表该类的Class对象
Class clazz = object.getClass();
// 利用StringBuilder来保存类信息
StringBuilder strBuffer = new StringBuilder();
// 获得类所在的包
Package packageName = clazz.getPackage();
// 输出类所在的包名
strBuffer.append("包名：").append(packageName.getName()).append("\t");
// 获得类的简单名称
String className = clazz.getSimpleName();
// 输出类的简单名称
strBuffer.append("类名：").append(className).append("\n");
strBuffer.append("公共构造方法：\n");
// 获得所有代表构造方法的Constructor数组
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
// 获得方法修饰符
String modifier = Modifier.toString(constructor.getModifiers());
// 查看修饰符是否含有“public”
if (modifier.contains("public")) {
//将此构造器的描述字符串输出
strBuffer.append(constructor.toGenericString()).append("\n");
}
}
strBuffer.append("公共域：\n");
// 获得代表所有域的Field数组
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
String modifier = Modifier.toString(field.getModifiers());
// 查看修饰符是否含有“public”
if (modifier.contains("public")) {
strBuffer.append(field.toGenericString()).append("\n");
}
}
strBuffer.append("公共方法：\n");
// 获得代表所有方法的Method[]数组
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
String modifier = Modifier.toString(method.getModifiers());
// 查看修饰符是否含有“public”
if (modifier.contains("public")) {
strBuffer.append(method.toGenericString()).append("\n");
}
}
return strBuffer.toString();
}
测试之：
首先写一个Bean类：
package ReflectStudy.Exa149;
public class Student {
private int id;
private String name;
private boolean male;
private double account;
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 boolean isMale() {
return male;
}
public void setMale(boolean male) {
this.male = male;
}
public double getAccount() {
return account;
}
public void setAccount(double account) {
this.account = account;
}
}
然后：
public static void main(String[] args) {
Student student = new Student();
student.setId(8);
student.setAccount(20);
student.setMale(true);
student.setName("麻子");
System.out.println(new StringUtils().toString(student));
}
运行之：
2）将类中的字段值打印出来
/**
* 打印出对象obj中字段的值
* @param obj 对象
* @return 字段值字符串
* @throws IllegalAccessException
*/
public static String toFieldString(Object obj) throws IllegalAccessException {
//如果该对象为空直接返回
if(obj==null) return null;
Class<?> cl=obj.getClass();
//如果该对象是字符串类型，直接返回之
if(cl==String.class) return (String)obj;
//如果该对象是数组对象，遍历之，并打印出各个对象中的字段值
if(cl.isArray()){
StringBuilder r= new StringBuilder(cl.getComponentType() + "[]{");
for(int i=0;i< Array.getLength(obj);i++){
if(i>0) r.append(" ");
Object val=Array.get(obj,i);
if(cl.getComponentType().isPrimitive())
r.append(val);
else r.append(toFieldString(val));
}
return r+"}";
}
//如果是普通对象，遍历其中的字段打印之（包括父类的）
StringBuilder r= new StringBuilder(cl.getName());
do{
r.append("[");
Field[] fields=cl.getDeclaredFields();
AccessibleObject.setAccessible(fields,true);
for(Field field:fields){
if(!Modifier.isStatic(field.getModifiers())){
if(!r.toString().endsWith("[")) r.append(",");
r.append(field.getName()).append("=");
Class<?> t= field.getType();
Object val= field.get(obj);
//t是不是基础类型
if(t.isPrimitive()) r.append(val);
else r.append(toFieldString(val));
}
}
r.append("]");
cl=cl.getSuperclass();
}while (cl!=null);
return r.toString();
}
测试之：
public static void main(String[] args) throws IllegalAccessException {
Student student = new Student();
student.setId(8);
student.setAccount(20);
student.setMale(true);
student.setName("麻子");
//System.out.println(toString(student));
System.out.println(toFieldString(student));
}
结果：
测试成功！！