Java学习笔记八（反射）

最新推荐文章于 2024-07-26 20:03:36 发布
最新推荐文章于 2024-07-26 20:03:36 发布
阅读量1.2k 收藏
点赞数
分类专栏： Java学习 Java读书笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luckyzhoustar/article/details/46727503
版权

 

 1.介绍

反射为Java程序在运行时提供了动态的能力，利用反射可以在运行时对程序进行动态的控制。本篇博客着重讲解一下Java中的反射。

 

 2.Class类的使用

在Java运行过程中，每个类被加载后都会在内存中产生一个对应的Class类对象，因此通过Class类的对象就可以拿到有关类的相关信息。下面演示一个实例。

<span style="font-family:SimSun;font-size:18px;">package com.Reflect;

//用来被加载类的父类
class MyFather 
{
	//父类的公共成员变量
	public int memberFather;
	//父类的公共方法
	public void methodFather()
	{
		System.out.println("我是从父类继承而来的方法methodFather！！！");
	}	
}
//用来被加载的类
class MySon extends MyFather 
{
	
	//子类的公共成员变量
	public int memberSonPublic;
	//子类的私有成员变量
	private int memberSonPrivate;
	//子类的公共方法
	public void methodSonPublic()
	{
		
		System.out.println("我是子类自己的方法methodSonPublic！！！");
	}	
	//子类的保护方法
	protected void methodSonProtected()
	{
		System.out.println("我是子类自己的方法methodSonProtected！！！");
	}
}
//主类
public class Sample34_1
{
	public static void main(String args[])
	{
     try
     {
	       //加载指定的类
	       Class c=Class.forName("com.Reflect.MySon");
	       //创建加载类的对象
	       MySon ms=(MySon)c.newInstance();
	       System.out.println(ms.getClass());
	       //调用创建对象的方法
	       System.out.println("===============调用创建对象的方法===================");
	       ms.methodSonProtected();
	       ms.methodSonPublic();
	       ms.methodFather(); 
	       //打印加载类的详细信息
	       System.out.println("==================加载类的信息======================");   
	       System.out.println(c.getName()+"类自己声明了"
	                        +c.getDeclaredFields().length+"个成员变量。");   
	       System.out.println(c.getName()+"类对外公布的方法有"
	                        +c.getMethods().length+"个。");  	
     }
	   catch(Exception e)
	   {
	   		e.printStackTrace();
	   }
	}
}
</span>


上面的实例通过Class对象的ForName方法加载相应的class对象，并通过Class对象的newInstance方法创建了其对象，紧接着调用了对象中的方法，接着打印了加载类的一些信息。


 3.Field类的使用

Field类的对象代表成员变量，携带成员变量的信息，注意的是与Class类类似，不可以通过构造器创建Field类的对象，对象都是通过Class类对象提供的get系列方法创建出来的。

<span style="font-family:SimSun;font-size:18px;">package com.Reflect;

import java.util.*;
import java.lang.reflect.*;
//自定义用来测试的类
class Student
{
	public int sage;//年龄
	private int sno;//学号
	public boolean gender;//性别 true-男  false-女
	public String sname;//姓名
	//构造器
	public Student(int sage,int sno,boolean gender,String sname)
	{
		
		this.sage=sage;
		this.sno=sno;
		this.gender=gender;
		this.sname=sname;
	}
}
//主类
public class Sample34_4
{
	public static void main(String args[])
	{
        try
        {
	        //创建Student类对象
	        Student tom=new Student(21,10001,true,"Tom");
	        //获取Student类对应的Class对象
	        Class dc=tom.getClass();
	        //获取Student类所有可以访问的成员变量对应的Field数组
	        Field[] fieldArray=dc.getFields();
	        //打印Student类对象各成员变量的详细信息
	        System.out.println("成员变量名\t成员变量类型\t\t成员变量值");
	        int size=fieldArray.length;
	        //循环处理Field数组
	        for(int i=0;i<size;i++)
	        {
	        	Field tempf=fieldArray[i];
	        	//打印成员变量名称
	        	System.out.print(tempf.getName()+"\t\t");
	        	//打印成员变量类型
	        	System.out.print(tempf.getType().toString()
	        	+((tempf.getType().toString().length()>7)?"\t":"\t\t\t"));
	        	//打印成员变量值
	        	System.out.println(tempf.get(tom));
	        }        	
        }
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
}
</span>

上述实例中，首先定义了Strudent类的对象，然后通过Student类对应的Class对象获取可以访问的成员变量的Field数组，紧接着就是调用Field类的方法，对成员变量的信息进行打印操作


 4.Method类的使用

Method类的对象代表一个方法，携带方法有关的信息，该对象只能通过Class类对象的get方法进行得到

<span style="font-family:SimSun;font-size:18px;">package com.Reflect;

import java.util.*;
import java.lang.reflect.*;
//自定义用来测试的类
class ForMethod 
{
	//声明静态方法sayHello，功能为在屏幕上打印字符串
	public static void sayHello(String name)
	{
		System.out.println("你好，"+name+"!!!");
	}
	//声明非静态方法generateNum，功能为产生min与max之间的随机数
	public String generateNum(int max,int min)
	{
		return (Math.random()*(max-min)+min)+"";
	}
}
//主类
public class Sample34_5
{
	public static void main(String args[])
	{
        try
        {
	        //创建ForMethod类对象
	        ForMethod fm=new ForMethod();
	        //获取ForMethod类对应的Class对象
	        Class fmc=fm.getClass();
	        //获取可以访问的方法对应的Method数组
	        Method[] ma=fmc.getMethods();
	        //对数组进行扫描打印方法的信息
	        System.out.println("方法名称\t返回值类型\t\t参数列表");
	        int size=ma.length;
	        for(int i=0;i<size;i++)
	        {
	        	Method tempm=ma[i];
	        	//打印方法名称
	        	String mname=tempm.getName();
	        	System.out.print(mname+((mname.length()>7)?"\t":"\t\t"));
	        	//打印方法的返回值类型
	        	String mReturnType=tempm.getReturnType().getName();
	        	System.out.print(mReturnType+((mReturnType.length()>15)?"\t":
	        	                    (mReturnType.length()>10)?"\t\t":"\t\t\t"));
	        	//循环打印方法的参数序列
	        	Class[] ca=tempm.getParameterTypes();
	        	int csize=ca.length;
	        	if(csize==0)
	        	{
	        		System.out.print("没有参数");
	        	}
	        	for(int j=0;j<csize;j++)
	        	{
	        		System.out.print(ca[j].getName()+((j==csize-1)?"":", "));
	        	}	        	
	        	//换行
	        	System.out.println();
	        }
	        //通过反射调用静态方法sayHello
	        System.out.println("==========通过反射调用静态方法sayHello===========");
	        ma[0].invoke(null,new Object[]{"王强"});
	        //通过反射调用非静态方法generateNum
	        System.out.println("========通过反射调用非静态方法generateNum========");
	        System.out.println(ma[1].invoke(fm,
	                           new Object[]{new Integer(100),new Integer(1000)}));
        }
		catch(Exception e)
		{
			e.printStackTrace();
		}          	
	}
}
</span>

该实例中首先创建了ForMethod类的对象，然后通过反射打印了Formethod类的所有可以访问到的方法，最后通过反射调用了ForMethod类中声明的两个方法


 5.Constructor类的使用

Constructor类代表一个构造器，携带有关构造器的相关信息，也是只能通过Class类对象的get系列方法获得。

<span style="font-family:SimSun;font-size:18px;">package com.Reflect;

import java.util.*;
import java.lang.reflect.*;
//自定义用来测试的类
class Student1
{
	String sname;//姓名
	int sage;//年龄
	//声明无参构造器
	public Student1()
	{
		sname="Tom";
		sage=23;
	}
	//声明有参构造器
	public Student1(String sname,int sage)
	{
		this.sname=sname;
		this.sage=sage;
	}
	//声明一个普通方法
	public void sayHello()
	{
		System.out.println("您好，我是"+sname+"，今年"+sage+"岁!!!");
	}
}
//主类
public class Sample34_6
{
	public static void main(String args[])
	{
        try
        {
	        //获取Student类对应的Class对象
	        Class sc=Student1.class;
	        //获取可以访问的构造器对应的Constructor数组
	        Constructor[] ca=sc.getConstructors();
	        //对数组进行扫描打印构造器的信息
	        System.out.println("构造器名称\t\t参数列表");
	        int size=ca.length;
	        for(int i=0;i<size;i++)
	        {
	        	Constructor tempc=ca[i];
	        	//打印构造器名称
	        	String cname=tempc.getName();
	        	System.out.print(cname+"\t\t");
	        	//循环打印构造器的参数序列
	        	Class[] pa=tempc.getParameterTypes();
	        	int psize=pa.length;
	        	if(psize==0)
	        	{
	        		System.out.print("没有参数");
	        	}
	        	for(int j=0;j<psize;j++)
	        	{
	        		System.out.print(pa[j].getName()+((j==psize-1)?"":", "));
	        	}	        	
	        	//换行
	        	System.out.println();
	        }
	        
	        //使用反射调用有参构造器创建对象
	        Student1 stu=(Student1)ca[0].newInstance(new Object[0]);
	        //调用创建对象的sayHello方法
	        stu.sayHello();	        
	        //使用反射调用有参构造器创建对象
	        stu=(Student1)ca[1].newInstance(new Object[]{"王强",new Integer(25)});
	        //调用创建对象的sayHello方法
	        stu.sayHello();     
        }
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
}
</span>

上述实例中，首先获得了Student类对应的Class对象，紧接着打印了所有Student类可以访问的构造器的信息，最后通过反射调用了Student类的构造器创建了两个对象并调用了SayHello方法。


 6.取消访问限制

当用Class对象的getDeclaredXXXs方法获得Field、Method或Constructor时，由于访问修饰符的限制，可能有些字段、方法或者构造器访问不到。如果要访问的话，需要先解除限制，然后再访问

若希望解除限制，需要使用java.lang.reflect.AccessibleObject类。

<span style="font-family:SimSun;font-size:18px;">package com.Reflect;

import java.lang.reflect.*;
//自定义用来测试的类
class Employee1
{
	private String sname;//员工姓名
	//私有方法
	private void sayHello()
	{
		System.out.println("您好，我是"+sname
		             +"，恭喜您成功访问了private的方法sayHello!!!");
	}
}
//主类
public class Sample34_8
{
	public static void main(String args[])
	{
		try
		{
			//创建Employee对象
			Employee1 tom=new Employee1();
			//获取Employee类对应的Class对象
			Class ec=tom.getClass();
			//获取Employee类声明的成员变量对应的Field数组
			Field[] fa=ec.getDeclaredFields();
			//设置sname成员变量的访问限制为允许
			fa[0].setAccessible(true);
			//设置sname成员变量的值
			fa[0].set(tom,"Tom");
			//获取Employee类声明的方法对应的Method数组
			Method[] ma=ec.getDeclaredMethods();
			//设置所有方法的访问限制为允许
			//ma[0].setAccessible(true);
			AccessibleObject.setAccessible(ma,true);
			//调用sayHello方法
			ma[0].invoke(tom,new Object[0]);			
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}	    	
	}
}
</span>

上述实例就是通过解除访问修饰符的限制来访问到私有变量。



LuckyZhouStar
关注
专栏目录
java学习笔记java反射机制
08-23
java学习笔记java反射机制
java基础学习笔记之反射
09-02
Java反射是Java编程语言的一个重要特性，它允许程序在运行时检查类的信息并动态地创建和操作类的对象。反射提供了一种方式，使得程序能够访问和修改私有成员（包括字段和方法），甚至调用私有构造器。这种能力使得...
public class 类名＜T＞简单解释
jian8182的博客
11-04 4446
T可以是任意的英文字母，代表泛型，即：广泛的类型
class和public class
Golden Summer的博客
07-11 1677
class和public class 1、class 先在一个Java文件中定义多个class，代码如下： class A{ } class B{ } class C{ } class D{ } class E{ } 创建一个Test.java源文件，在该文件中定义了五个类A类,B类,C类,D类和E类,使用javac命令编译之后得到五个.class文件，分别是A.class,B.class,C.class,D.class和E.class。 D:\java\java-project>javac
Java学习笔记
Piglett的博客
12-30 1093
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java反射（个人学习笔记）
Rsecret的博客
05-27 1441
Java反射是指在运行时动态地获取类的信息，并可以通过该信息来操作类或对象。通过反射，我们可以在运行时获取类的字段、方法、构造函数等信息，并能够动态地创建对象、调用方法、访问和修改字段的值。
Java反射基础学习笔记
qq_36722262的博客
01-22 1018
Java反射要学习哪些内容，其实要知道的东西很少，也很简单掌握。主要如下：第一部分就是要理解什么是反射。只需要知道反射可以获取类的全部信息，其主要也是用来获取类的全部信息。第二就是会使用反射。包括如何获取反射类、构造函数、成员变量、成员函数、注解等，以及一些常用方法的使用。
Java反射学习笔记
TroyeMartin的博客
09-20 127
Java反射学习笔记
Java 学习笔记
weixin_42098295的博客
05-13 2020
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记：反射
这是一个博客
02-29 834
看标题
Java学习笔记（完结）
weixin_52798101的博客
07-19 1729
Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的高级程序设计语言。 Java 可运行于多个平台，如 Windows, Mac OS 及其他多种 UNIX 版本的系统。 本教程通过简单的实例将让大家更好的了解 Java 编程语言。 移动操作系统 Android 大部分的代码采用 Java 编程语言编程。............
java学习笔记第十一天
最新发布
Word_seeker的博客
07-26 1209
Java中的反射（Reflection）是指在运行时检查或操作类、方法、字段等程序结构的能力。通过反射，我们可以在程序运行时动态地获取类的信息、调用方法、操作字段等，而不需要在编译时就确定这些操作。反射机制允许程序在运行时通过名称来获取类的信息，并且可以在运行时动态地创建对象、调用方法、访问属性等。
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
PreparementStatement接口
06-17 3949
在敲机房收费系统的时候，就曾经遇到过SQL注入的问题，也写过一篇博客。而在学习java的过程中，有一次遇到了，不错的是，JDBC为我们提供了一个PreparementStatement接口，可以防止SQL的注入，下面介绍一下。   1.SQL注入问题 在以前过程中，总是采取拼接SQL语句的方式，来实现数据的增删改查！ String Sql=select * from user whe
Java读书笔记十一（Java中的内省机制）
08-04 2790
1.前言 最近在学习Java的时候，突然发现了这个概念，鉴于好奇心的压迫，于是打算写一篇博客来总结一下。  2.什么是内省机制 为了让程序员们更好的从左Java对象的属性，SUN公司开发了一套API，就被我们称为“内省”，有利于我们对类对象的属性的操作，减少了代码的数量。  3.内省和反射有什么区别 反射式在运行状态把Java类中的各种成分映射成相应的
Java读书笔记一（异常处理）
06-28 1831
1.介绍 在开发过程中，都会遇到程序运行时的异常，例如逻辑错误、硬件故障等，本篇博客将会详细的介绍一下Java中的异常处理机制。  2.Try和Catch捕获异常 我们在处理异常过程中经常用到的就是Try和Catch语句了。try语句块能够指出可能出现的异常，随后通过一个或者多个Catch语句块来捕获。   2.1.简单的Try和Catch语法 packa
Java学习笔记十（注解）
07-03 1473
1.介绍 注解是JavaSE5.0开始提供的一项新特性，利用此特性可以通过特定的注解标签为程序提供一些描述性信息。这些描述性信息可以在编译或运行时为编译器、运行环境提供附加的信息，从而简化开发。  2.自定义注解 1.声明自己的注解 @interface { [default]} @interface myTest{ //自定义注解属性 String ms
Java学习笔记：数据库连接与问题解决
Java学习笔记涵盖了广泛的Java编程基础知识，特别是与数据库交互的相关技术。本文档首先介绍了连接数据库的关键步骤，包括： 1. **驱动程序加载**：通过Java反射机制，使用Class.forName()方法加载特定数据库的驱动...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值