1、先来一个最简单的。通过反射得到方法、字段
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
public class Reflect1 {
@Test
public void getMethods() throws Exception{ //得到所有(自己类中)的方法，包括private的方法
Class<?> strClazz = Class.forName("java.lang.String");
Method[] declaredMethods = strClazz.getDeclaredMethods();
for(Method method : declaredMethods){
System.out.println(method.getName());
}
}
@Test
public void getFields() throws Exception{ //得到所有(自己类中)的字段，包括private的字段
Class<?> strClazz = Class.forName("java.lang.String");
Field[] declaredFields = strClazz.getDeclaredFields();
for(Field field : declaredFields){
System.out.println(field.getName());
}
}
}
2、通过反射调用方法
import java.lang.reflect.Method;
import org.junit.Test;
/**
* 通过反射调用方法
* @author Administrator
*
*/
public class Reflect2 {
public Integer add(int num1 , int num2){
return num1 + num2;
}
public String say(String name){
return "hello "+name;
}
public String print(String str){
return str;
}
public String print(){
return "hello world";
}
/**
* 传统方式
* @description
* @Date Jul 21, 2017
*/
@Test
public void ordinaryTest(){
Reflect2 r2 = new Reflect2();
r2.add(1, 2);
r2.say("张三");
r2.print("hello world");
}
/**
* 通过反射调用方法
* @description
* @Date Jul 21, 2017
*/
@Test
public void reflectTest() throws Exception{
Class<?> clazz = Reflect2.class; //得到class
Reflect2 reflect2 = (Reflect2) clazz.newInstance(); //得到新的对象
Method addMmethod = clazz.getMethod("add", new Class[]{int.class,int.class});
Integer addResult = (Integer) addMmethod.invoke(reflect2, 1,3);
System.out.println(addResult);
System.out.println("----------------------------");
Method sayMethod = clazz.getMethod("say", new Class[]{String.class});
Object invoke = sayMethod.invoke(reflect2, "张三");
System.out.println(invoke);
System.out.println("----------------------------");
Method printMethod = clazz.getMethod("print", new Class[]{String.class});
Object invoke2 = printMethod.invoke(reflect2, "hello world");
System.out.println(invoke2);
System.out.println("----------------------------");
Method printMethod2 = clazz.getMethod("print", new Class[]{});
Object invoke3 = printMethod2.invoke(reflect2);
System.out.println(invoke3);
}
}
3、通过反射访问私有属性、方法
首先有个类
public class TestClass {
private String name;
public String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
private String say(){
return "hello world";
}
private String say(String name){
return "hello "+name;
}
public String say2(){
return "hello world";
}
public String say2(String name){
return "hello "+name;
}
}
接着 通过反射访问上边类中的方法属性（包括私有方法属性）
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
/**
* 反射访问私有方法，私有属性
* @author Administrator
*
*/
public class Reflect4 {
/**
* 访问 public方法
* @description
* @Date Jul 21, 2017
* @throws Exception
*/
@Test
public void getPublicMethod() throws Exception{
Class<?> clazz = TestClass.class;
Object obj = clazz.newInstance();
Method method1 = clazz.getDeclaredMethod("say2");
Object value1 = method1.invoke(obj);
System.out.println(value1);
System.out.println("------------------------");
Method method2 = clazz.getDeclaredMethod("say2",new Class[]{String.class});
Object value2 = method2.invoke(obj, "张三");
System.out.println(value2);
}
/**
* 访问私有方法
* @description
* @Date Jul 21, 2017
* @throws Exception
*/
@Test
public void testGetPrivateMethod() throws Exception{
Class<?> clazz = TestClass.class;
TestClass obj = (TestClass) clazz.newInstance();
Method method1 = clazz.getDeclaredMethod("say");
method1.setAccessible(true); // 访问私有方法，如果不设置 会报错 java.lang.IllegalAccessException: Class com.test.reflect.Reflect4 can not access
// a member of class com.test.reflect.TestClass with modifiers "private"
Object value1 = method1.invoke(obj);
System.out.println(value1);
System.out.println("---------------------");
Method method2 = clazz.getDeclaredMethod("say",new Class[]{String.class});
method2.setAccessible(true);
Object value2 = method2.invoke(obj, "张三");
System.out.println(value2);
System.out.println("---------------------");
}
/**
* 访问public 属性
* @description
* @Date Jul 21, 2017
* @throws Exception
*/
@Test
public void testGetPublicField() throws Exception{
Class<?> clazz = TestClass.class;
TestClass obj = (TestClass) clazz.newInstance();
Field declaredField = clazz.getDeclaredField("address");
declaredField.set(obj, "济南");
System.out.println(obj.getAddress());
}
/**
* 访问private属性
* @description
* @Date Jul 21, 2017
* @throws Exception
*/
@Test
public void testGetPrivateField() throws Exception{
Class<? extends Object> clazz = TestClass.class;
TestClass obj = (TestClass) clazz.newInstance();
Field declaredField = clazz.getDeclaredField("name");
declaredField.setAccessible(true); // 访问私有属性，不设置会报错 java.lang.IllegalAccessException: Class com.test.reflect.Reflect4 can not access
// a member of class com.test.reflect.TestClass with modifiers "private"
declaredField.set(obj, "张三");
System.out.println(obj.getName());
}
}
4、clazz.getMethods 和clazz.getDeclaredMethods的不同
另建一个类，继承 TestClass
public class TestClass2 extends TestClass{
private String testSay(){
return "hello world";
}
public String testSay2(){
return "hello world";
}
}
测试不同
/**
* clazz.getMethods 和clazz.getDeclaredMethods的不同
* @description
* @Date Jul 21, 2017
*/
@Test
public void testDifferent(){
Class<?> clazz = TestClass2.class;
Method[] methods = clazz.getMethods(); // 取出本类中非private的方法。同时会把 父类(父类的父类，父类的父类的父类，。。。)中的方法（不包括private）也取出来
for(Method method : methods){
System.out.println(method.getName());
}
System.out.println("-----------------------------");
Method[] declaredMethods = clazz.getDeclaredMethods(); // 自己定义的类中的所有的方法
for(Method method : declaredMethods){
System.out.println(method.getName());
}
}
通过结果可以看出
clazz.getMethods(); // 取出本类中非private的方法。同时会把 父类(父类的父类，父类的父类的父类，。。。)中的方法（不包括private）也取出来。
而clazz.getDeclaredMethods(); // 自己定义的类中的所有的方法。
5、反射的简单应用，利用反射复制一个对象
首先创建一个两类。Child 和 ChildBean。利用反射将Child 复制为 ChildBean
Child类
public class Child {
private Integer id;
private String name;
private Integer age;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Child [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
ChildBean 类
public class ChildBean {
private Integer id;
private String name;
private Integer age;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "ChildBean [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
利用反射复制
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.apache.commons.lang.StringUtils;
import org.junit.Test;
/**
* 利用反射，复制
* @author Administrator
*
*/
public class Reflect3 {
// obj ---> newClazz
public <T> T copyByReflect(Object obj, Class<T> newClazz) throws Exception{
T newObj = newClazz.newInstance();
Class<?> objClazz = obj.getClass();
Field[] objFields = objClazz.getDeclaredFields();
Field[] newFields = newClazz.getDeclaredFields();
if(newFields.length > 0 && objFields.length >0){
for(Field newField : newFields){
String newFieldName = newField.getName();
for(Field objField : objFields){
String objFieldName = objField.getName();
if(objFieldName.equals(newFieldName)){
String upperFieldName = StringUtils.capitalize(objFieldName); //capitalize 首字母大写（如： name---> Name, id--->Id）
// get obj field value
Method getGetMethod = objClazz.getMethod("get"+upperFieldName);
Object value = getGetMethod.invoke(obj);
// set newObj field value
Method getSetmethod = newClazz.getMethod("set"+upperFieldName, objField.getType());
getSetmethod.invoke(newObj, value);
}
}
}
}
return newObj;
}
@Test
public void testMain() throws Exception{
Child child = new Child();
child.setAddress("山东");
child.setAge(18);
child.setId(1);
child.setName("张三");
System.out.println("child:"+child);
ChildBean newChild = this.copyByReflect(child, ChildBean.class);
System.out.println("childBean:"+newChild);
}
}
相关推荐
Java 反射学习 Java 反射是 Java 程序设计语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说 "自审 "，并能直接操作程序的内部属性。Java 反射的能力在实际应用中非常有价值，例如，使用它能获得 ...
反射学习笔记是深入理解这一关键特性的重要资源。以下是对"反射学习笔记"中可能包含的知识点的详细阐述： 1. **什么是反射**：反射是Java提供的一种机制，能够在运行时获取类的信息（如类名、属性、方法等）并动态...
总结而言，膝跳反射和反射学习教案旨在向学生介绍反射的概念、分类、反射弧的组成以及大脑在反射过程中的作用。通过生动直观的膝跳反射实验，不仅能够加深学生对基础生物学知识的理解，而且能够激发学生对进一步探索...
本文将深入探讨“反射学习PPT + TEST CODE”中的核心知识点。 一、反射基础 1. 类型信息：反射允许程序在运行时获取关于类、接口、结构等类型的信息，如类型名称、属性、方法、构造函数等。这在设计动态代码、元...
### 反射学习资料 #### 引言 反射是Java编程语言中的一个重要概念，它允许程序在运行时检查和修改自身结构与行为的能力。这种能力对于框架开发、单元测试、序列化、远程调用等领域至关重要。本文将深入探讨Java...
斯金纳操作性条件反射学习理论.ppt
在“JAVA反射学习”这个主题中，我们将深入探讨以下几个关键知识点： 1. **什么是反射**：反射是Java提供的一种能力，通过Class对象来获取关于类的所有信息，并能在运行时创建和访问对象，调用方法，甚至修改私有...
### c# 反射学习 #### 一、概述 C#中的反射机制是.NET框架提供的一种强大工具，它允许程序在运行时动态地查询、加载和操作类型信息。通过反射，开发人员能够实现代码的灵活性与扩展性，尤其是在构建插件架构、动态...
### Java反射机制详解 在Java领域，反射（Reflection）是一个强大的功能，允许程序在运行时检查和修改其结构和行为。这种能力对于框架设计、动态代理、类库扩展等场景至关重要。下面，我们将深入探讨Java反射的核心...
针对两轮机器人的平衡控制问题, 在学习自动机理论的框架中, 提出一种基于操作条件反射学习自动机的 仿生学习模型. 该模型引入认知学习单元和取向单元, 分别用来实现操作行为学习和指导系统进化的方向. 模拟两轮...
在路由反射的框架下，BGP路由器可以扮演路由反射器的角色，负责传播IBGP学习到的路由信息给特定的IBGP对等体，而不是要求所有IBGP路由器之间建立连接。这种方法降低了网络的复杂性和维护成本。 2. **设计标准** -...
Java反射是Java编程语言中的一种强大机制，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射是通过java.lang.Class类和java.lang.reflect包中的类来实现的。本篇笔记将深入探讨...
Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、对象等的内部信息。这一机制对于理解和实现高级框架、动态代理、元数据处理等场景至关重要。以下是对Java反射机制的详细说明：...
根据给定的文件信息，我们可以总结出以下关于Java反射机制的知识点： ### 一、反射基本概念 反射是Java的一项强大功能，它允许程序在运行时检查类的信息（如类名、方法、字段等），并可以创建和操作对象。通过反射...
在本学习笔记中，我们将深入探讨JavaWeb应用中反射的运用，以及如何通过提供的"src"目录下的源代码来实践这些概念。 首先，反射的核心类是`java.lang.Class`，它代表了Java程序中的类或接口。通过`Class`对象，我们...
本资料包主要关注Java的反射机制，通过深入学习，你可以更好地理解和掌握这一强大工具。 在Java中，反射API提供了访问和控制类、接口、字段和方法的能力，即使在编译时未知的情况下也能操作它们。这一特性在许多...
### 光的反射学习知识点详解 #### 一、光的反射定律 1. **反射条件**： - 当光遇到不同介质的界面时（如桌面、水面等），会发生反射现象。 2. **有关反射的基本名词**： - **法线**：垂直于介质交界面的直线。 ...
【C#运行时类型标识与反射】 在C#编程语言中，运行时类型标识（Runtime Type Identification，RTTI）是程序在运行时检查和利用对象实际类型的能力。这一特性对于实现多态性和动态类型操作至关重要。C#提供了三个...
射(OCR) 学习控制方法. 该方法采用Elman 网络构造滑模面-行为对的评价函数, 通过滑模面的变化设计奖赏函数, 根据奖赏信号更新评价函数, 实现行为选择概率的更新. 通过每轮次熵的定义, 定量分析了所学知识的变化...