创建对象UserOne、UserTwo
 
public class UserOne {
 
private Integer id;
 
private String username;
 
private String password;
 
// Getter and Setter 、、、
 
}
 
public class UserTwo {
 
private Integer id;
 
private String username;
 
// Getter and Setter 、、、
 
}
 
编写基于反射的工具类
 
import com.google.common.collect.Lists;
 
import com.wayne.common.exception.CopyPropertyException;
 
import java.lang.reflect.Field;
 
import java.lang.reflect.Method;
 
import java.util.List;
 
public class BaseUtil {
 
/**
 
* 将一个集合中对象的值拷贝到另一个对象，属性相同即赋值
 
* @param source 源数据，将此对象数据取出
 
* @param tClass 目标对象，将取出的数据赋值到该对象中
 
* @param 源数据类型
 
* @param 目标数据类型
 
* @return 被赋值后的目标对象集合
 
* @throws CopyPropertyException 自定义异常，通过反射创建对象或调用方法时抛出的异常
 
*/
 
public static List copyProperties(List source, Class tClass) throws CopyPropertyException {
 
// 判断传入源数据是否为空，如果空，则抛自定义异常
 
if(null == source) {
 
throw new CopyPropertyException("数据源为空");
 
}
 
// 创建一个集合，用于存储目标对象，全部数据抓换完成后，将该集合返回
 
List targetList = Lists.newArrayList();
 
// 循环取到单个源对象
 
for(T t : source) {
 
// 获取源对象的类的详情信息
 
Class> sClass = t.getClass();
 
// 获取源对象的所有属性
 
Field[] sFields = sClass.getDeclaredFields();
 
// 获取目标对象的所有属性
 
Field[] tFields = tClass.getDeclaredFields();
 
E target;
 
try {
 
// 通过类的详情信息，创建目标对象 这一步等同于UserTwo target = new UserTwo()；
 
target = tClass.newInstance();
 
} catch (Exception e) {
 
e.printStackTrace();
 
throw new CopyPropertyException("目标对象创建失败");
 
}
 
// 循环取到源对象的单个属性
 
for(Field sField : sFields) {
 
// 循环取到目标对象的单个属性
 
for(Field tField : tFields) {
 
// 判断源对象的属性名、属性类型是否和目标对象的属性名、属性类型一致
 
if(sField.getName().equals(tField.getName()) && sField.getGenericType().equals(tField.getGenericType())) {
 
try {
 
// 获取源对象的属性名，将属性名首字母大写，拼接如：getUsername、getId的字符串
 
String sName = sField.getName();
 
char[] sChars = sName.toCharArray();
 
sChars[0] -= 32;
 
String sMethodName = "get" + String.valueOf(sChars);
 
// 获得属性的get方法
 
Method sMethod = sClass.getMethod(sMethodName);
 
// 调用get方法
 
Object sFieldValue = sMethod.invoke(t);
 
// 获取目标对象的属性名，将属性名首字母大写，拼接如：setUsername、setId的字符串
 
String tName = tField.getName();
 
char[] tChars = tName.toCharArray();
 
tChars[0] -= 32;
 
String tMethodName = "set" + String.valueOf(tChars);
 
// 获得属性的set方法
 
Method tMethod = tClass.getMethod(tMethodName, tField.getType());
 
// 调用方法，并将源对象get方法返回值作为参数传入
 
tMethod.invoke(target, sFieldValue);
 
break;
 
} catch (Exception e) {
 
e.printStackTrace();
 
throw new CopyPropertyException("转换失败，请检查属性类型是否匹配");
 
}
 
}
 
}
 
}
 
// 将通过反射创建的目标对象放入集合中
 
targetList.add(target);
 
}
 
// 返回集合
 
return targetList;
 
}
 
}
 
测试；
 

 
image.png

 
以下代码为一个工具类
 
package com.imooc.reflect;
 
import java.lang.reflect.Method;
 
public class ClassUtil {
 
public static void printClassMessage(Object obj){
 
//要获取类的信息，首先要获取类的类类型
 
Class c = obj.getClass();//传递的是哪个子类的对象，c就是该子类的类类型
 
//获取类的名称
 
System.out.println("类的名称为:"+c.getName());
 
/*
 
* Method类，方法对象
 
* 一个成员方法就是一个Method对象
 
* getMethods()方法获取的是所有的public的函数，包括父类继承而来的
 
* getDeclaredMethods()获取的是所有该类自己声明的方法，部位访问权限
 
*/
 
Method[] methods = c.getMethods();
 
//
 
for(int i=0;i
 
//得到方法的返回值类型的类类型
 
Class returnType = methods[i].getReturnType();
 
System.out.print(returnType.getName()+" ");
 
//得到方法的名称
 
System.out.print(methods[i].getName()+"(");
 
//获取参数类型--》得到的参数列表的类型de类类型
 
Class[] paramType = methods[i].getParameterTypes();
 
for(Class class1:paramType){
 
System.out.print(class1.getName()+",");
 
}
 
System.out.println(")");
 
}
 
}
 
}
 
//output:
 
//类的名称为:java.lang.String
 
//boolean equals(java.lang.Object,)
 
//java.lang.String toString()
 
//int hashCode()
 
//.......
 
以下代码为测试类：
 
package com.imooc.reflect;
 
public class TestClassUtil {
 
public static void main(String[] args) {
 
String string = "hello";
 
ClassUtil.printClassMessage(string);
 
Integer n1 = 1;
 
ClassUtil.printClassMessage(n1);
 
}
 
}
 
截图如下：
 
以上就是小编为大家带来的Java反射之通过反射获取一个对象的方法信息(实例代码)的全部内容了，希望对大家有所帮助，多多支持脚本之家~

 

 
通过Java反射获得对象里面的所有字段名以及字段对应的值public static void test(Bean bean) {
 
Field[] fields = bean.getClass().getDeclaredFields();
 
for(Field field :fields) {
 
//设置是否允许访问，不是修改原来的访问权限修饰词。
 
field.setAccessible(true);
 
//获取字段名，和字段的值
 
System.out.println("name: "+field.getName() + "value: " +field.get(bean));
 
}
 
}
 
测试Bean@Data
 
public class Bean{
 
private String userName;
 
private String userId;
 
private String userPwd;
 
private String userPhone;
 
}
 
调用public static void main(String[] args){
 
Bean bean = new Bean();
 
bean.setUserName("张大炮");
 
bean.setUserId("zdp2000");
 
bean.setUserPwd("zhangdapaopwd123");
 
bean.setUserPhone("18666886688");
 
test(bean);
 
}

 
Java反射 -Java反射对象创建
 
我们可以使用反射动态创建类的对象。通过调用其中一个构造函数。
 
然后我们可以访问对象的细分的值，设置它们的值，并调用它们的方法。
 
有两种方法来创建对象：
 
使用no-args构造函数
 
使用带参数的构造函数
 
无参数构造函数
 
如果您有一个 Class 对象的引用，您可以创建一个对象该类对Classclass使用 newInstance()方法。
 
此方法不使用参数，并且是等效的使用new运算符的类的no-args构造函数。
 
MyClass m = myObject.newInstance();class MyClass {
 
public MyClass() {
 
System.out.println("called");
 
}
 
}
 
public class Main {
 
public static void main(String[] args) throws InstantiationException {
 
Class personClass = MyClass.class;
 
try {
 
MyClass p = personClass.newInstance();
 
System.out.println(p);
 
} catch (InstantiationException | IllegalAccessException e) {
 
System.out.println(e.getMessage());
 
}
 
}
 
}
 
上面的代码生成以下结果。
 
called
 
MyClass@15db9742
 
带参数的构造函数
 
您可以通过调用特定的构造函数使用反射创建对象。它涉及两个步骤。
 
获取构造函数的实例
 
调用newInstance来调用它
 
你可以得到这个构造函数的引用，如下所示：
 
Constructor cons = myClass.getConstructor(int.class, String.class);
 
然后调用带有参数的 newInstance()方法来创建一个对象。
 
import java.lang.reflect.Constructor;
 
import java.lang.reflect.InvocationTargetException;
 
class MyClass {
 
public MyClass(int i, String s) {
 
System.out.println("called");
 
System.out.println(i);
 
System.out.println(s);
 
}
 
}
 
public class Main {
 
public static void main(String[] args) {
 
Class myClass = MyClass.class;
 
try {
 
Constructor cons = myClass.getConstructor(int.class,
 
String.class);
 
MyClass chris = cons.newInstance(1, "abc");
 
System.out.println(chris);
 
} catch (NoSuchMethodException | SecurityException | InstantiationException
 
| IllegalAccessException | IllegalArgumentException
 
| InvocationTargetException e) {
 
System.out.println(e.getMessage());
 
}
 
}
 
}
 
上面的代码生成以下结果。
 
called
 
1
 
abc
 
MyClass@15db9742
 
调用方法
 
我们可以通过方法引用使用反射调用方法。
 
要调用方法，请调用方法引用的 invoke()方法。
 
它的第一个参数是它来自和的对象第二个参数是相同顺序中所有参数的varargs作为方法的声明。
 
在静态方法的情况下，我们只需要为第一个参数指定null。
 
import java.lang.reflect.InvocationTargetException;
 
import java.lang.reflect.Method;
 
class MyClass {
 
public MyClass() {
 
}
 
public void setName(String n) {
 
System.out.println(n);
 
}
 
}
 
public class Main {
 
public static void main(String[] args) {
 
Class myClass = MyClass.class;
 
try {
 
MyClass p = myClass.newInstance();
 
Method setName = myClass.getMethod("setName", String.class);
 
setName.invoke(p, "abc");
 
} catch (InstantiationException | IllegalAccessException
 
| NoSuchMethodException | SecurityException | IllegalArgumentException
 
| InvocationTargetException e) {
 
System.out.println(e.getMessage());
 
}
 
}
 
}
 
上面的代码生成以下结果。
 
abc