Java 反射 -超详细讲解（附源码）

最新推荐文章于 2024-09-06 18:09:12 发布
最新推荐文章于 2024-09-06 18:09:12 发布
阅读量7.4w 收藏 883
点赞数 159
分类专栏： JavaSE 文章标签： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lililuni/article/details/83449088
版权

  学到spring框架的时候，发现反射思想很重要，故特此写下此文，以加深理解。

文章目录

1：反射概述

  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
  实际上，我们创建的每一个类也都是对象，即类本身是java.lang.Class类的实例对象。这个实例对象称之为类对象，也就是Class对象。那么，Class对象又是什么对象呢？

2：Class对象特点

  下图是Class类的api（图片来自于Java基础之—反射（非常重要））

在这里插入图片描述
   从图中可以得出以下几点：

  1. Class 类的实例对象表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有很多的实例，每个类都有唯一的Class对象。
  2. Class 类没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机自动构造的。也就是说我们不需要创建，JVM已经帮我们创建了。
  3. Class 对象用于提供类本身的信息，比如有几种构造方法， 有多少属性，有哪些普通方法

3：反射的使用

  假设我们现在有一个Hero类

package pojo;
public class Hero {
	public String name; //姓名
    public float hp; //血量
    public float armor; //护甲
    public int moveSpeed; //移动速度
}

1:获取类对象

获取类对象有3种方式

  1. Class.forName（）（常用）
  2. Hero.class
  3. new Hero().getClass()

在一个JVM中，一种类，只会有一个类对象存在。所以以上三种方式取出来的类对象，都是一样。（此处准确是在ClassLoader下,只有一个类对象）

示例：

package pojo;
public class ObjectTest {
	
	public static void main(String[] args) {
        String className = "pogo.Hero";
		try {
        	//获取类对象的第一种方式
            Class pClass1 = Class.forName(className);
            //获取类对象的第二种方式
            Class pClass2 = Hero.class;
            //获取类对象的第三种方式
            Class pClass3 = new Hero().getClass();
            System.out.println(pClass1==pClass2);//输出true
            System.out.println(pClass1==pClass3);//输出true
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 }
}

  三种方式中，常用第一种，第二种需要导入类的包，依赖太强，不导包就抛编译错误。第三种对象都有了还要反射干什么。一般都第一种，一个字符串可以传入也可写在配置文件中等多种方法。

2 利用反射机制创建对象

基本步骤
  与传统的通过new 来获取对象的方式不同反射机制，反射会先拿到Hero的“类对象”,然后通过类对象获取“构造器对象”再通过构造器对象创建一个对象，具体步骤：

1.获取类对象 Class class = Class.forName("pojo.Hero");
2.获取构造器对象 Constructor con = clazz.getConstructor(形参.class);
3 获取对象 Hero hero =con.newInstance(实参);

上面是最简单的获取方法，当Hero的构造方法不是无参构造方法时，获取构造器对象略有不同，见下面测试：

构造方法不同时，获取构造器对象的方法

示例：

  1. Hero类添加6种构造方法
//---------------构造方法-------------------
	//（默认的构造方法）
	Hero(String str){
		System.out.println("(默认)的构造方法 s = " + str);
	}
	
	//无参构造方法
	public Hero(){
		System.out.println("调用了公有、无参构造方法执行了。。。");
	}
	
	//有一个参数的构造方法
	public Hero(char name){
		System.out.println("姓名：" + name);
	}
	
	//有多个参数的构造方法
	public Hero(String name ,float hp){
		System.out.println("姓名："+name+"血量："+ hp);
	}
	
	//受保护的构造方法
	protected Hero(boolean n){
		System.out.println("受保护的构造方法 n = " + n);
	}
	
	//私有构造方法
	private Hero(float hp){
		System.out.println("私有的构造方法   血量："+ hp);
	}
  1. 通过反射机制获取对象
package test;
public class ConstructorTest {
	
	 
	/*
	 * 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
	 * 
	 * 1.获取构造方法：
	 * 		1).批量的方法：
	 * 			public Constructor[] getConstructors()：所有"公有的"构造方法
	            public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
	     
	 * 		2).获取单个的方法，并调用：
	 * 			public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
	 * 			public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
	 * 		
	 * 2.创建对象
	 * 		Constructor对象调用newInstance(Object... initargs)
	 */

	 
	public static void main(String[] args) throws Exception {
		//1.加载Class对象
		Class clazz = Class.forName("pojo.Hero");
		
		
		//2.获取所有公有构造方法
		System.out.println("**********************所有公有构造方法*********************************");
		Constructor[] conArray = clazz.getConstructors();
		for(Constructor c : conArray){
			System.out.println(c);
		}
		
		
		System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
		conArray = clazz.getDeclaredConstructors();
		for(Constructor c : conArray){
			System.out.println(c);
		}
		
		System.out.println("*****************获取公有、无参的构造方法*******************************");
		Constructor con = clazz.getConstructor(null);
		//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
		//2>、返回的是描述这个无参构造函数的类对象。
		System.out.println("con = " + con);
		//调用构造方法
		Object obj = con.newInstance();
		
		
		System.out.println("******************获取私有构造方法，并调用*******************************");
		con = clazz.getDeclaredConstructor(float.class);
		System.out.println(con);
		//调用构造方法
		con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
		obj = con.newInstance(100);
	}
	

}

输出：

**********************所有公有构造方法*********************************
public pojo.Hero(java.lang.String,float)
public pojo.Hero(char)
public pojo.Hero()
************所有的构造方法(包括：私有、受保护、默认、公有)***************
private pojo.Hero(float)
protected pojo.Hero(boolean)
public pojo.Hero(java.lang.String,float)
public pojo.Hero(char)
public pojo.Hero()
pojo.Hero(java.lang.String)
*****************获取公有、无参的构造方法*******************************
con = public pojo.Hero()
调用了公有、无参构造方法执行了。。。
******************获取私有构造方法，并调用*******************************
private pojo.Hero(float)
私有的构造方法   血量：100.0

总结：

1.获取构造器对象方法：
  1).批量的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
  2).获取单个的方法:
public Constructor getConstructor(Class… parameterTypes): 获取单个的"公有的"构造方法
public Constructor getDeclaredConstructor(Class…parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；

3: 获取成员变量并使用

基本步骤

1.获取HeroPlus类的对象 new方法/第2章中的方法 h
2. 获取属性 Field f1 = h.getDeclaredField("属性名")
3. 修改属性 f1.set(h，实参)，注意这里的h是对象，不是类对象

示例：

  1. 新增HeroPlus类
package pojo;
public class HeroPlus {
	public String name;
    public float hp;
    public int damage;
    public int id;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public HeroPlus(){
         
    }
    public HeroPlus(String string) {
        name =string;
    }
 
    @Override
    public String toString() {
        return "Hero [name=" + name + "]";
    }
    public boolean isDead() {
        // TODO Auto-generated method stub
        return false;
    }
    public void attackHero(HeroPlus h2) {
        System.out.println(this.name+ " 正在攻击 " + h2.getName());
    }
}
  1. 获取属性并修改
package test;
public class ParaTest {
	 public static void main(String[] args) {
         HeroPlus h =new HeroPlus();
         //使用传统方式修改name的值为garen
         h.name = "garen";
        
         try {
             //获取类HeroPlus的名字叫做name的字段
             Field f1= h.getClass().getDeclaredField("name");
             //修改这个字段的值
             f1.set(h, "teemo");
             //打印被修改后的值
             System.out.println(h.name);
              
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
 }
}

补充：
getField和getDeclaredField的区别
   getField 只能获取public的，包括从父类继承来的字段。
   getDeclaredField 可以获取本类所有的字段，包括private的，但是 不能获取继承来的字段。 (注： 这里只能获取到private的字段，但并不能访问该private字段的值,除非加上setAccessible(true))

4: 获取成员方法并使用

  1. 获取HeroPlus类的对象 h
  2. 获取成员方法：
    public Method getMethod(String name ，Class<?>… parameterTypes):获取"公有方法"；（包含了父类的方法也包含Object类）
    public Method getDeclaredMethods(String name ，Class<?>… parameterTypes) :获取成员方法，包括私有的(不包括继承的)
    参数解释：
      name : 方法名；
      Class … : 形参的Class类型对象
  3. 调用方法
    Method --> public Object invoke(Object obj,Object… args):
    参数说明：
      obj : 要调用方法的对象；
      args:调用方式时所传递的实参；

示例：

package test;
public class MethodTest {
	public static void main(String[] args) {
	
	 HeroPlus h = new HeroPlus();
	 
     try {
         // 获取这个名字叫做setName，参数类型是String的方法
         Method m = h.getClass().getMethod("setName", String.class);
         // 对h对象，调用这个方法
         m.invoke(h, "盖伦");
         // 使用传统的方式，调用getName方法
         System.out.println(h.getName());

     } catch (Exception e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }

 }
}

5: 获取main方法并使用

示例：

  1. HeroPlus 新增main方法
public static void main(String[] args) {
		System.out.println("执行main方法");
	}
  1. 通过下面步骤获取main方法1
package test;
public class MainTest {
	public static void main(String[] args) {
		try {
			//1、获取HeroPlus对象的字节码
			Class clazz = Class.forName("pojo.HeroPlus");
			
			//2、获取main方法,第一个参数：方法名称，第二个参数：方法形参的类型，
			 Method methodMain = clazz.getMethod("main", String[].class);
			//3、调用main方法
			// methodMain.invoke(null, new String[]{"a","b","c"});
			//第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
			//这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。所以需要将它强转。
			 methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
			// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
	}
}

4 : 关于反射的用法举例

  反射非常强大，但是从上面的记录来看，反而觉得还不如直接调用方法来的直接和方便2。

  通常来说，需要在学习了Spring 的依赖注入，反转控制之后，才会对反射有更好的理解，所以先这里举两个例子，来演示一下反射的一种实际运用3。

1:通过反射运行配置文件内容

  1. 首先准备两个业务类
package service;
public class Service1 {
    public void doService1(){
        System.out.println("业务方法1");
    }
}


package service;
public class Service2 {
	public void doService2(){
        System.out.println("业务方法2");
    }
}
  1. 当需要从第一个业务方法切换到第二个业务方法的时候，使用非反射方式，必须修改代码，并且重新编译运行，才可以达到效果
package service;
public class CommonTest {
	  public static void main(String[] args) {
		  //new Service1().doService1();
		  //必须重新修改代码
	        new Service2().doService2();
	    }
}
  1. 使用反射方式则方便很多
  1. 首先准备一个配置文件，就叫做spring.txt吧, 放在src目录下。
    里面存放的是类的名称，和要调用的方法名。首先准备一个配置文件，就叫做spring.txt吧, 放在src目录下。里面存放的是类的名称，和要调用的方法名。
  2. 在测试类Test中，首先取出类名称和方法名，然后通过反射去调用这个方法。
  3. 当需要从调用第一个业务方法，切换到调用第二个业务方法的时候，不需要修改一行代码，也不需要重新编译，只需要修改配置文件spring.txt，再运行即可。

示例：
spring.txt内容

class=reflection.Service1
method=doService1

测试类

package service;
public class ReflectTest {
	@SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) throws Exception {
 
        //从spring.txt中获取类名称和方法名称
        File springConfigFile = new File("H:\\eclpise-workspace\\reflect-demo\\src\\spring.txt");
        Properties springConfig= new Properties();
        springConfig.load(new FileInputStream(springConfigFile));
        String className = (String) springConfig.get("class");
        String methodName = (String) springConfig.get("method");
         
        //根据类名称获取类对象
        Class clazz = Class.forName(className);
        //根据方法名称，获取方法对象
        Method m = clazz.getMethod(methodName);
        //获取构造器
        Constructor c = clazz.getConstructor();
        //根据构造器，实例化出对象
        Object service = c.newInstance();
        //调用对象的指定方法
        m.invoke(service);
         
    }
}

2:通过反射越过泛型检查

  泛型是在编译期间起作用的。在编译后的.class文件中是没有泛型的。所有比如T或者E类型啊，本质都是通过Object处理的。所以可以通过使用反射来越过泛型。

示例：

package test;
public class GenericityTest {
	public static void main(String[] args) throws Exception{
		
	ArrayList<String> list = new ArrayList<>();
	list.add("this");
	list.add("is");
	
	//	strList.add(5);报错
	
	/********** 越过泛型检查    **************/
	
	//获取ArrayList的Class对象，反向的调用add()方法，添加数据
	Class listClass = list.getClass(); 
	//获取add()方法
	Method m = listClass.getMethod("add", Object.class);
	//调用add()方法
	m.invoke(list, 5);
	
	//遍历集合
	for(Object obj : list){
		System.out.println(obj);
		}
	}

}

GitHub源码：java反射

  1. Java基础之—反射（非常重要） ↩︎

  2. 反射有什么用 ↩︎

  3. 深入分析Java方法反射的实现原理
    后记：
      本文部分内容引用自csdn的敬业的小码哥和How2jJava，如有侵权，请联系我 ↩︎

刘卡卡阿
关注
专栏目录
java反射(转)
lorry1113的专栏
03-22 1144
Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。 那么什么是Java的反射呢？ 大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的...
JAVA的反射
程序小白的成长
12-09 385
主要内容：定义用途反射机制的相关类反射Class类反射属性反射构造方法反射方法总结 定义 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 用途 在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放...
java中的反射
最新发布
isolusion的博客
09-06 1152
反射是java基础的核心，反射是获取类信息的能力。类信息包括：方法、变量、接口、父类、构造器、类名等。
JAVA
沉心听雨
03-25 571
http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html反射机制详解 java反射详解 本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。 下面开始正文。 【案例1】通过一个对象获得完整的包名和类名
Java 反射
weixin_30603633的博客
01-04 544
Java 反射 标签 ： Java基础 动态语言 动态语言，是指程序在运行时可以改变其结构：新的函数可以被引进，已有的函数可以被删除等在结构上的变化。比如众所周知的ECMAScript(JavaScript)便是一个动态语言。除此之外如Ruby、Python等也都属于动态语言，而C、C++等语言则不属于动态语言。(引自: 百度百科) var execS...
Java基础之—反射（非常重要）
热门推荐
sinat_38259539的博客
05-13 74万+
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的
java反射
weixin_47276069的博客
07-18 568
Setting——Editor——File and Code templates——"+"——名称为“new.xml”——输入“<?>”——单击"OK"2.类的class静态属性（一个类只有一个class,实例化多次对应的都是同一个class，所以class可以用==进行比较，a.getClass==b.getClass）若是想要获得父类和子类所以的属性，则需要进行递归，先对子类进行属性的获得，然后获得子类的父类，如果不是Object类型，则使用递归将父类传入继续进行属性的获得。
java源码api-java-:JAVA常用API源码解析
05-25
"java源码api-java-"这个主题专注于讲解Java API的常用组件，帮助开发者深入理解其工作原理，提升编程技能。 Java API覆盖了多个方面，包括集合框架、IO流、多线程、网络编程、反射机制等。以下是一些关键知识点： ...
java8源码-java-learning-copy:java-学习-复制
06-04
含博客讲解和源码实例，采用 maven 构建，分模块学习，涉及反射，代理，多线程，IO，集合类等核心知识。 如果觉得不错，请先在这个仓库上点个 star 吧，这也是对我的肯定和鼓励，谢谢了。 不定时进行调整和补充，...
java8源码-java-learning:java练习库
06-04
含博客讲解和源码实例，采用 maven 构建，分模块学习，涉及反射，代理，多线程，IO，集合类等核心知识。 如果觉得不错，请先在这个仓库上点个 star 吧，这也是对我的肯定和鼓励，谢谢了。 不定时进行调整和补充，...
Javabook-cn:《 Java程序设计源码》-源码程序
03-24
6. **反射机制**：Java反射机制允许在运行时动态访问类和对象，源码中可能会有动态加载类、获取类信息、调用方法的例子。 7. **泛型**：泛型是Java 5引入的新特性，用于提高代码类型安全性和重用性。源码中会有泛型...
Java之反射
weixin_44222066的博客
07-14 1030
Java之反射 1，什么是反射 反射java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法 2，反射：java.lang.Class 类类 反射中三个相关的包 类属性 java.lang.reflect.Field 类方法 java.lang.reflect.Method 构造器 java.lang.reflect.construct 获取Student.java...
java反射详解
白强
09-21 393
我喜欢程序员，他们单纯、固执、容易体会到成就感；面对压力，能够挑灯夜战不眠不休；面对困难，能够迎难而上挑战自我。他们也会感到困惑与傍徨，但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧开创属于自己的事业”。我想说的是，其实我是一个程序员。 本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去...
java反射深入_Java反射
weixin_39836860的博客
02-23 78
Java基础 - 反射一、作用“反射是框架设计的灵魂”，它可以将类的各个组成部分封装为一个个的对象，通过 Java 的反射机制，程序员可以更深入地控制程序的运行过程。二、好处可以在程序运行过程中操作这些封装的对象可以解耦，提高程序的可扩展性三、使用首先准备一个Person类public class Person {private String name;private Integer age;pu...
Java 反射机制浅析
weixin_30906701的博客
01-27 119
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序...
spring-boot-starter-logging 源码讲解
04-25
spring-boot-starter-logging 是 Spring Boot 中的一个模块，提供了日志的支持，它基于 Commons Logging、Logback 和 Log4j2 实现了日志功能。在使用 Spring Boot 时，默认的日志框架是 Logback，因此在引入 spring-boot-starter-logging 后，我们就可以使用 Logback 记录日志了。 该模块主要包含以下组件： 1. spring-boot-starter-log4j2：使用 Log4j2 进行日志记录。 2. spring-boot-starter-logging：使用 Logback 进行日志记录。 3. spring-boot-starter-tomcat：Tomcat 容器启动的日志支持。 4. spring-boot-starter-jetty：Jetty 容器启动的日志支持。 在使用 Spring Boot 进行开发时，我们可以通过日志来了解应用的运行情况，排查问题等。而 spring-boot-starter-logging 模块的存在，简化了日志的配置，提高了开发效率。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值