Java反射机制学习有感

合集下载

java反射机制总结--ITeye技术网站

首页资讯精华论坛问答博客专栏群组更多 ▼您还未登录 !登录注册jczghost博客微博相册收藏留言关于我java反射机制总结博客分类：java-高级JavaStrutsBean框架Mobile经过多方面的资料搜集整理，写下了这篇文章，本文主要讲解java的反射和内省机制，希望对大家有点帮助,也希望大家提出不同的看法！1).反射是java的基础技术，在我们用到的框架如:struts,spring,hibernate,junit等都用到了反射技术，所以了解反射对我们来说也很重要。

要了解反射技术，必须要了解一个类Class类。

2).平时我们定义class的时候都是小写，这里讲的Class是大写，此时它代表一类事物，java类用于描述一类事物的共性，如该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定，不同的事物对象有不同的属性值。

java程序中的java类，属于同一类事物，描述这类事物的Java类名就是Class.，就比如众多的人可以用一个Person类表示一样，众多的java类用Class来表示。

3).Class类代表Java类，它(Class类)的各个实例对象分别对应各个类在内存中的字节码，那么什么叫字节码呢? java源程序被编译成一堆二进制的class代码，当我们需要用到某个类时，首先把类的字节码加载到内存中来，然后再用该字节码去复制一个个的实例对象来，每份字节码都是Class类的实例对象，即Class类的实例对象就代表内存中字节码。

如：public static void main(String[] args) throws Exception {Class cls1 = Date.class;//cls1代表Date类在内存中的字节码Class cls2 = String.class;//cls2代表String类在内存中的字节码Class cls3 = String.class;//cls3代表String类在内存中的字节码System.out.println(cls2 == cls3);//true:同一份字节码在内存中的地址相同}4).一个类被类加载器加载到内存中，占用一片存贮空间，这个空间里的内容就是这个类的字节码，不同的类的字节码是不同的,所以它们在内存中的内容是不同的，这一个个的空间分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class类型.5).如何得到各个字节码对应的实例对象?(Class类型):即得到字节码的三种方式：.)类名.class 例如：System.class//写程序的时候就知道类的名称.)对象.getClass() 例如：new Date().getClass().)Class.forName() 例如：Class.forName("java.util.Date");//类的字符串的完整名称做反射的时候常用第三种,因为写源程序的时候不知道类的名称,在运行的时候根据传递的字符串来创建.例如：public static void main(String[] args) throws Exception {Date nowDate = new Date();Class cls1 = nowDate.getClass();//getClass()方法返回创建该对象的字节码Class cls2 = Date.class;Class cls3 = Class.forName("java.util.Date");System.out.println(cls1);// class java.util.DateSystem.out.println(cls1 == cls2);// trueSystem.out.println(cls1 == cls3);// true//这说明三个应用变量引用的是同一份字节码}例如：public static void main(String[] args) throws Exception {Date nowDate = new Date();Date tomDate = new Date();System.out.println(nowDate == tomDate);// falseSystem.out.println(nowDate.getClass() == tomDate.getClass());// true//同一个类的字节码是相同的(即使是不同的实例对象.getClass()依然是相等的).}6)Class.forName()的作用:得到这个类的字节码，包含下面两种情况.这个类的字节码已经加载到Java虚拟机中，只需要找到返回..这个类的字节码在Java虚拟机没找到，于是用类加载器加载，然后把类的字节码缓存起来再返回..7)8个基本类型和一个void共9个预定义的Class实例对象例如:public static void main(String[] args) throws Exception {System.out.println(int.class.isPrimitive());//trueSystem.out.println(int.class == Integer.class);//falseSystem.out.println(int.class == Integer.TYPE);//true,TYPE表示基本类型 Class实例。

Java反射机制

Java反射机制一、Java反射机制1、什么是java语言的反射机制JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2、Java反射机制主要提供了以下功能：●在运行时判断任意一个对象所属的类getClass()●在运行时构造任意一个类的对象●在运行时判断任意一个类所具有的成员变量和方法●在运行时调用任意一个对象的方法●生成jdk动态代理3、Java反射的用途Java 语言的反射机制提供了一种非常通用的动态连接程序组件的方法。

它允许你的程序创建和维护任何类的对象（服从安全限制），而不需要提前对目标类进行硬编码。

这些特征使得反射在创建与对象一同工作的类库中的通用方法方面非常有用。

例如，反射经常被用于那些数据库，XML，Eclipse或者其它的外部的框架中,如Struts，Spring，Hibernate。

初始化语句块：每创建对象new一次，都会执行；静态static初始化语句块：第一次创建new时，执行一次；之后不再执行；二、类加载机制与ClassLoader1、什么是类加载器Classloader与普通程序不同的是，Java程序（class文件）并不是本地的可执行程序。

当运行Java程序时，首先运行JVM（Java虚拟机），然后再把Java class加载到JVM里头CodeSegment(代码段)运行，负责加载Java class的这部分就叫做Class Loader。

因此Classloader也叫做类加载器。

2、Java类加载机制●类加载是动态执行的，也就是说当我们用到的时候才会去加载，如果不用的话，就不会去加载我们的类。

●类加载有两种方式：第一种就是new一个对象的时候，另一种就是当一个类的静态代码被调用的时候●静态初始化语句块在加载时只执行一次，而初始化语句块在每次new出新的对象是都会执行，等同于构造方法中的语句。

反射(reflection)学习整理

反射学习整理【摘要】本文主要通过自己对反射机制的总结编写的文档，主要目的就是为了自己以后能可以参考温习也可以方便刚刚入门的同仁们学习指导，通过doc的编写相信可以在帮助别人的同时提高自己。

反射机制；Reflection API；如何使用反射机制；反射机制的应用举例；第一节反射机制什么是反射机制，说的通俗一些就是在java运行期间动态加载一些不确定的类对象，那么我们如何使用一个类的呢？当然大多数情况下我们是使用一个确定的类，然后通过在内存中的加载再使用之。

其实在一个project中会有很多类，虚拟机并不是在每一次运行时都将所有的类都进行加载然后解析的，是在我们使用的过程中才会被加载，这个大家可以看一下ClassLoader（在后期中我也会编写ClassLoader相关的文章总结）反射机制提供的功能：加载运行时才能确定的数据类型；解析类的结构，获取其内部的信息；能够操作的类型或者实例；1. 访问属性；2. 调用方法；3. 创建新的对象；以上的功能我会在接下来的文字中都进行阐述，然后每一个功能点都会通过代码的形式进行逐一的说明举例；1.1动态加载类Java虚拟机在运行是能加载的类型有如下几种：类接口；数组；枚举；注解（Annotation，可以参见我的另一篇文档，《java Annotation学习文档》）；基本数据类型；在类加载的时候，JVM会自动加载上述类型对应的Class对象。

package com.wangwenjun.demo;import java.util.ArrayList;public class ReflectionDemo1 {private final static String LIST_STRING="java.util.ArrayList"; //动态加载java.util.ArrayList的类路径@SuppressWarnings("unchecked")public static void main(String[] args) {try {Class<?> clazz=Class.forName(LIST_STRING);//通过反射获取运行时的ClassArrayList<Object> list=(ArrayList<Object>)clazz.newInstance(); //通过newInstance方法获取Objectlist.add("hello");System.out.println(list.size()+":"+list.get(0));} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalAccessException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}执行结果为：1:hello通过上面的代码我们可以总结出来使用Reflection大致需要如下的几步：获取目标对象的Class对象；调用Class对象内省方法获取目标对类成员信息；访问目标类的成员属性；1.2解析类的结构通过第一步的操作，我们获取了目标对象的class之后就可以解析出来class对应的内部结构；别不多说直接上代码，来看看如何解析出来目标对象；我们定义一个Teacher类package com.wangwenjun.demo;public class Teacher {private String username;private int age;private static int total;public Teacher(){super();total++;}public Teacher(String username,int age){super();ername = username;this.age = age;total++;}public String getUsername() {return username;}public void setUsername(String username) {ername = username;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public static int getTotal() {return total;}public static void setTotal(int total) {Teacher.total = total;}@Overridepublic String toString(){return"UserName:"+ername+",age:"+this.age;}}假如说上述的Teacher类是在我们运行时才知道的一个类，也就是说是我们运行时才能确定的一个类，那么我们就可以通过反射的形式将它解析出来，包括它的属性，方法，以及构造函数等等。

java总结与心得体会5篇

java总结与心得体会5篇（经典版）编制人：__________________审核人：__________________审批人：__________________编制单位：__________________编制时间：____年____月____日序言下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。

文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢!并且，本店铺为大家提供各种类型的经典范文，如总结报告、演讲致辞、事迹材料、学习心得、合同协议、条据文书、自我鉴定、教学资料、作文大全、其他范文等等，想了解不同范文格式和写法，敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!Moreover, our store provides various types of classic sample essays for everyone, such as summary reports, speeches, deeds, learning experiences, contract agreements, normative documents, self-evaluation, teaching materials, essay summaries, other sample essays, etc. If you want to learn about different sample essay formats and writing methods, please stay tuned!java总结与心得体会5篇心得是一种感受性文字，所以只有结合自身的实际经历才会写出有趣的文章，平日里相信大家一定经常使用到心得，本店铺今天就为您带来了java总结与心得体会5篇，相信一定会对你有所帮助。

java学习心得体会_JAVA实训的心得（通用9篇）

java学习心得体会_JAVA实训的心得（通用9篇）java学习_JAVA实训的心得篇11、我感觉学习java应该是循环渐进，有始有终，按部就班，脚踏实地。

java是一门有着阶梯性的一们语言，如果要学习它。

我觉得最好还是按照java的学习体系，先学习什么，在学习什么，只有这样，我们在学习中才会遇到更少的麻烦。

java是一门更倾向于网络的语言。

不要上来就学习JSP，这样不好，因为这没有基础。

在以后的学习中很可能遇到很多的麻烦，这就不好了。

2、信心，恒心，毅力是最重要的。

这是我们必须具备的心理素质。

要是学习这门语言开始的时候很有兴趣，遇到苦难就退缩，这样最终会放弃学习java，没有经历风雨怎么见彩虹。

编程就是有的时候就是那么这么人。

会遇到很多的困惑。

但是一旦你弄懂了，或者是你把问题解决了，你会感到很兴奋，编程的快乐就在此了。

3、多看看一些资料，多多的向高手请教，这样才好。

要学会总结和领会，当然，学习java一个人有一个人的想法，也有自己的独特学习方法。

总之适合自己的就是最好的。

java学习心得体会_JAVA实训的心得篇2从大三开始算，我学习java已经有一年的时间了，不过虽然时间长，但是对于现在的我还是一个初学者，懂不了多少的java初学者。

期间曾迷茫过，曾困惑过，走了不少的弯路，老师布置的试验作业每次都是不会做，每次都是要问同学，这个代码什么意思啊?为什么用这条代码，用别的不行吗?甚至后来根本没耐心问，索性就复制同学的作业交上去。

但是都是各种0分，害的同学也这样，不过他能找老师反驳，而我却没实力。

渐渐的，我认识到这样下去是不行的，我必须改正自己的学习态度和方式。

接下提到的就是我这一年来的java学习心得。

刚一开始学习java时，我就已经学习过C语言，不过C语言学的不是很好，所以开始看到java的时候我很反感，看着源代码，都不知道失什么意思。

看书的时候一看到源代码就头疼，因为根本看不懂。

那段时间根本就是一无所获，在图书馆借了一本书，关java的语法特性，与别的语言相比的优点，什么跨平台，源代码公开，什么write 、 once 、 run 、 anywhere，能说得头头是道，可是一到具体的问题，想写一些具体的东西，问题就都来了，根本不知道该怎么下手。

java学习笔记及心得

第一部分基础一、请描述java语言的反射机制作用Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

二、单例模式1、懒汉械public class SingLeton {private static SingLeton singLeton = null;private SingLeton() {//readConfig();}public static SingLeton getSingLeton() {if (singLeton == null) {singLeton = new SingLeton();}return singLeton;}……}2、饿汉模式public class SingLeton {private static SingLeton singLeton = new SingLeton();private SingLeton() {//readConfig();}public static SingLeton getSingLeton() {return singLeton;}……}两种模式区别在于，懒汉模式是在需要时，才实例化；而饿汉模式是在加载时实例化。

饿汉式是线程安全的，因为虚拟机保证了只会装载一次，在装载类的时候是不会发生并发的。

懒汉式是非线程安全，要实现线程安全，加 "synchronized";public static synchronized Singleton getInstance(){}懒汉式是典型的时间换空间;饿汉式是典型的空间换时间三、代理模式ng.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

清单 1. Proxy 的静态方法// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器static InvocationHandler getInvocationHandler(Object proxy)// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象static Class getProxyClass(ClassLoader loader, Class[] interfaces)// 方法 3：该方法用于判断指定类对象是否是一个动态代理类static boolean isProxyClass(Class cl)// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)ng.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

java的反射原理

java的反射原理宝子！今天咱们来唠唠Java里超级有趣又有点神秘的反射原理。

你可以把Java的反射想象成是一个超级侦探。

在Java的世界里呢，正常情况下，我们都是按照常规的方式去使用类和对象的。

就像是你每天走同一条路去上班或者上学，规规矩矩的。

但是反射呢，它就像是发现了一条秘密通道，可以在运行的时候，去探索那些我们原本只能在代码编写时才知道的类的信息。

比如说，有一个类就像一个神秘的城堡，里面有好多宝藏（成员变量、方法啥的）。

正常情况下，我们只能从大门（常规的类使用方式）进去拿东西。

但是反射这个小机灵鬼，它可以绕到城堡的后面，找到一些隐藏的入口，然后悄悄地进去查看宝藏。

那它是怎么做到的呢？在Java里，每个类在运行的时候都有一个对应的Class对象。

这个Class对象就像是这个类的身份证一样，上面记录着这个类的所有信息。

反射就是通过获取这个Class对象，然后开始它的探秘之旅的。

当我们想要使用反射去操作一个类的时候，就好像我们在和这个类玩一个猜谜游戏。

我们可以通过类的名字，就像喊出这个类的名字一样，然后Java就会找到这个类对应的Class对象。

比如说，有个类叫MyClass，我们可以用Class.forName("MyClass")这样的方式来获取它的Class对象。

这就像是在一个满是人的房间里，大喊一声“谁是MyClass”，然后那个代表MyClass的家伙就会站出来。

一旦拿到了这个Class对象，哇塞，那就像拿到了城堡的地图一样。

我们可以通过这个Class对象去查看这个类里有哪些成员变量。

就好比在城堡里找宝箱，我们可以用getFields()或者getDeclaredFields()这样的方法。

getFields()就像是找那些公开摆放的宝箱，大家都能看到的；而getDeclaredFields()呢，就像是找那些隐藏起来的宝箱，只有这个城堡内部知道的。

同样的，对于方法也是这样。

java心得体会总结(通用8篇)

java心得体会总结(通用8篇)java心得体会总结要怎么写，才更标准规范？根据多年的文秘写作经验，参考优秀的ja va心得体会总结样本能让你事半功倍，下面分享【java心得体会总结(通用8篇)】，供你选择借鉴。

java心得体会总结篇1此次只培训了短短的三周。

虽说时间很短，但其中的每一天都使我收获很大、受益匪浅，它不但极大地加深了我对一些理论知识的理解，不仅使我在理论上对Java有了全新的认识，在实践能力上也得到了提高，真正地做到了学以致用，更学到了很多做人的道理，对我来说受益非浅。

除此以外，我知道了什么叫团队，怎样和团队分工合作;同时我还学会了如何更好地与别人沟通，如何更好地去陈述自己的观点，如何说服别人认同自己的观点。

这也是第一次让我亲身感受到理论与实际的相结合，让我大开眼界。

也是对以前所学知识的一个初审吧!这次培训对于我以后学习、找工作也是受益菲浅的，在短短的三周中相信这些宝贵的经验会成为我今后成功的重要的基石;这对于我的学业，乃至我以后人生的影响无疑是极其深远的。

这次培训虽然是我们的第一次，不过同学们表现不错，由此看来，我们在进入大学的这几个月里学到了不少的专业知识，只是自己感觉不到而已。

对于所学专业，我们不能过于自卑和担忧，否则会妨碍自己学习。

培训是学习Java的重要环节，有利于我们巩固专业知识、掌握工作技能，提高就业筹码。

我把本次为期三周的培训看作是“理论与实践相结合的桥梁”。

通过这周的培训和学习，我知道了此次培训的目的，也清楚目前自己的不足，那就是缺乏相应的知识与经验，对所学的专业知识不能够很好地运用于实践操作。

正所谓“百闻不如一见”，经过这次自身的切身实践，我才深切地理会到了“走出课堂，投身实践”的必要性。

平时，我们只能在课堂上与老师一起纸上谈兵，思维的认识基本上只是局限于课本的范围之内，也许就是这个原因就导致我们对专业知识认识的片面性，使得我们只知所以然，而不知其之所以然!限制了我们网络知识水平的提高。

JAVA反射

jaｖａ中得反射总结刚开始学习jaｖａ得时候真得很难理解反射到底就是个什么东西一些书籍，哪怕就是很经典得书籍都解释得让人感觉懵懵得,或许得确就是我太笨况且,网上说在将来学习框架得时候需要经常应用到反射机制,这样一来总让人心里有些不安就方才偶然又把讲解反射得章节与视频瞧了一点，觉得能理解一些了现在决定一鼓作气,边瞧边写,顺便把一些主要得内容与操作都记载到这里我想,对于我这么一个笨笨得人来说，学习得最好方法也许就就是不断重复遇到不懂得知识就停下来把以往得重新学一遍,虽然浪费了很多时间,但对我也有些效果我得理解就是:所谓反射,就就是根据一个已经实例化了得对象来还原类得完整信息至少对我而言,我认为它带给我得好处就是,让我从下往上得又了解了一遍面向对象x_x 在此又痛恨一边那些厚部头们,把我得脑细胞搞死一片Ｃｌaｓｓ类如果要完成反射,那么必须了解Clasｓ类实例1:通过对象取得包名与类名编译结果如下,注意包得编译方式即可此处得getＣlasｓ()方法就是默认继承自Oｂject类得在ｊaｖa中,Ｏbｊect类就是所有类得父类,同样,所有类得实例化对象也都就是Claｓｓ类得实例因此,这样一来就会牵扯到向上转型与向下转型得概念由于向下转型得不安全因素,在这里泛型也会接踵而来（不过我想说得就是,此处得泛型设计很刺眼！尼玛,整个javａ得语法设计同样刺眼,超恶心!!！)实例2:Class类得实例化由于Clasｓ类没有构造方法,所以实例化Ｃlass类得方式有点特殊,有三种方式:•对象、getClａss( )•类、Class•foｒNａｍe( )其中，ｆorNaｍe（ )方法需要重点掌握,因为它可以在类不确定得情况下实例化Class，更具灵活性Clasｓ类得应用Class类中有一个方法叫做ｎewInｓtance（ ),它可以用来创建一个Ｃlass类对象得新实例怎么说呢？Class对象包含得内容就就是反射好得那个类,我们要构造那个类得新实例(新对象) 实例3：Ｃlass类得无参构造对象这样就通过无参数得形式构造了一个新得对象,如同正常模式中通过无参构造方法来构造新对象一样我们知道,类中除了有无参构造方法,还会存在有参数得构造方法那在反射中如何通过有参数得形式构造对象呢？接着瞧实例4:Claｓs类得有参构造对象我们还就是使用Ｓｔｒing类做例，因为Ｓtring类用得比较多,便于理解这里需要注意得就是，构造方法需要使用getCｏnstrｕctor（）方法获得至于参数类型则就是:原有类型、cｌａｓs还有一点,无论就是有参还就是无参，这里所使用得构造方法,原本得类里面必须对应存在那么,如何才能知道原有类里面得构造方法,普通方法,继承得父类等详细信息呢？接着瞧获取类得结构要通过反射获取类得结构我们这里要导入一个新得包ｊaｖａ、laｎｇ、reｆｌect实例5:取得类得构造方法1３１41５１61718 ／/这里得getConstructo ｒs()方法返回得就是一个Ｃon ｓtr ｕｃｔor 数 Constru ｃｔor<?>[] ｃｏns = ｃ、getConstr ｕc ｔｏrs();//打印得方式您可以自己写,为了方便我用Arrays 、toS ｔring(),凑合着Ｓyst ｅm 、out 、println(A ｒray ｓ、t ｏString(cons));} ｝我选择了Boo ｌean 类来做例，因为Ｂoo ｌe ａｎ类得构造方法就两个,方便瞧实例6:取得类所实现得接口１2３45678910111２131４ imp ｏrt java 、util 、Ａrrays; publ ｉc class Demo ｛ p ｕblic s ｔa ｔi ｃ vo ｉd main(Ｓｔring[] ａrgs) thro ｗｓ Exc ｅｐtion Ｃla ｓs<?> c = ｎull; ｔry ｛ c ＝ C ｌａs ｓ、for Ｎa ｍe(＂j ａv ａ、la ｎg 、Bo ｏl ｅan"); } ｃatch (Clas ｓＮｏtFou ｎdExc ｅpt ｉon ｅ) { ｅ、ｐri ｎtStack Ｔrace （); ｝ C ｌａss<?>[］ in = c 、getInt ｅrfaces()； System 、ｏｕｔ、p ｒintln(Ar ｒａys 、toS ｔｒin ｇ（ｉｎ）); } }没什么好说得,瞧结果实例7:取得父类34５６78９10１１1２１３Class<?＞ c ＝nulｌ;try ｛ｃ = Class、foｒNａme（"java、laｎg、Booｌｅan"）;} catch (ClaｓsNoｔFounｄExcｅption e) ｛e、pｒiｎtStaｃkTrace()；}／／注意了,这里不会就是数组,whｙ？Clａsｓ<?> ｓｕ = c、getSuperclass();System、out、ｐｒintｌn(ｓu);}}别忘了,java中就是单继承，父类只有一个实例8:取得类得全部方法12３４5678９１011１21314１51６17ｉｍport java、lang、ｒeflect、Method;ｐｕblｉc class Demo {publiｃstａtiｃvoｉd maｉｎ（Strｉng［］ args) thrｏwｓＥxceptiｏClass<?> c = null;ｔｒy {c ＝Claｓs、forNａmｅ（"jａva、lang、Bｏoleａn")；} catcｈ（ＣlａsｓNoｔFｏunｄExcｅptiｏn e) ｛e、pｒiｎtＳtacｋTｒaｃｅ();}Mｅｔhoｄ［］ m ＝ｃ、geｔMethods();／/好吧，这次我就大发慈悲得写个打印列表出来for （int i = 0; i ＜m、leｎgth；ｉ＋+）｛Ｓｙstem、out、ｐrintln(m[i])；｝}}截取一部分,瞧瞧,意思下就行了……这几个例子都比较简单实例9:取得本类得全部属性geｔDｅｃｌaredFielsd（)方法可以获取全部属性，geｔＦieｌds()只能获取公共属性实例10:获取本类中属性得值要注意得就是:ｓｅtAcceｓｓｉblｅ(）方法可以设置就是否访问与修改私有属性坦白说，ｊava学到现在我还没发现什么能亮瞎我钛金眼得知识在里边每次都就是写一堆繁琐得语法实现个小玩意儿,不然就就是拼命调用ＡＰI，拼命得抛异常让本身显得不够紧凑得代码变得愈发累赘如果我喜欢一门语言,在我利用它做出东西来之前,它本身得特性必须能够打动我显然,ｊaｖa并不让我快乐,也许很多程序员跟我一样就是被迫使用ｊaｖａ得仅以此来安抚我那颗孤独编码得心,下面接着瞧内容反射得应用实例11:通过反射修改属性几个方法都就是有联系得,如果瞧不懂就先熟悉上面几个例子实例１2:通过反射调用方法这里演示了一个普通得有参方法与一个静态方法既然有参数得都写出来了,那么无参得就更简单了,直接传入一个对象即可实例13:通过反射操作数组这里要注意一点,ｇｅｔpoｎentTｙｐe（）返回得就是数组元素得Ｃｌass暂时就写这么多,我瞧得书中还有反射在工厂模式中得应用无非就是用forName()方法替换一下,没什么可说得我就是个jａva初级黑,我恨java那种恶心得语法与设计这都就是为了Aｎdrｏiｄ,为了打基础,为了适应以后得工作Fucｋ javａ……。

java中反射的理解

java中反射的理解
Java中的反射是一种强大的机制，它允许在运行时获取一个对象的各种信息，包括其类名、属性、方法等。

通过反射机制，我们可以动态地加载和使用类，而不必提前知道类的名称。

这种灵活性为Java应用程序的开发提供了很多便利和可能性。

反射的基本实现机制是通过Java的Class对象来访问一个类的信息。

每个类都有一个对应的Class对象，可以通过类名、对象实例等方式来获取这个Class对象。

通过Class对象，我们可以获取到一个类的所有信息，包括属性、方法、构造函数等。

反射机制提供了很多方法来获取这些信息，比如:getFields()、getMethods()、getConstructors()等。

通过反射机制，我们可以实现很多功能，比如动态代理、动态加载类、动态调用方法等。

其中，动态代理是反射机制应用最广泛的一种方式，它可以在运行时动态地生成一个代理对象，代理对象可以用来调用原始对象的方法，并在调用前后进行一些特殊处理。

反射机制虽然强大，但也有其局限性。

由于反射是在运行时动态地获取和使用类的信息，因此会带来一定的性能损失。

此外，由于反射机制可以访问私有属性和方法，因此可能会破坏类的封装性，导致代码安全问题。

总的来说，反射机制是Java语言的一项重要特性，它为Java应用程序的开发和调试提供了很多便利和可能性，但同时也要注意其使用的局限性和安全性。

Java反射技术总结

Java反射技术总结第一篇：Java反射技术总结Java反射技术知识点总结1、反射：反射是指程序可以访问、检测和修改它本身状态或行为的一种能力。

2、Java语言的反射机制主要提供以下功能：在运行时判断任意一个对象所属的类在运行时构造任意一个类的对象在运行时判断任意一个类所具有的成员变量和方法在运行时调用任意一个类所具有的成员变量和方法生成动态代理3、在ng.reflect包当中提供了实现反射机制的类：Class类：代表一个类。

Field类：代表类的成员变量，也称为类的属性。

Method类：代表类的方法。

Constructor类：代表类的构造方法。

Array类：该类提供动态地生成和访问java数组的方法。

4、Class实例: Class类和其它的类一样继承自Object类，Class 对象包含了与类相关的信息。

事实上，Class对象就是用来创建类的所有的“普通”对象的。

类是程序的一部分，每个类都有一个Class对象。

换言之，每当编写并且编译了一个新类时，就会产生一个Class对象（恰当地说，该对象被保存在一个同名的.class文件中）。

在运行时，当我们想生成这个类的对象时，运行这个程序的java虚拟机（JVM）首先检查这个类的Class 对象是否已经加载。

如果尚未加载，JVM就会根据类名查找.class文件，并将其载入。

一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象。

这些对象都会对应于同一个Class对象。

要想使用反射，首先需要获得待处理类或对象所对应的Class实例。

获取Class实例的四种方式：第一种：调用类本身的.class属性。

Class c =String.class;第二种：调用对象的getClass()方法获取该对象的Class实例。

String str = “abc”;Class c = str.getClass();第三种：使用Class 类的静态方法forName()，用类的全名（包名.类名）来获取一个Class实例。

Java反射使用总结

Java反射使用总结反射机制是什么反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射机制能做什么反射机制主要提供了以下功能：•在运行时判断任意一个对象所属的类；•在运行时构造任意一个类的对象；•在运行时判断任意一个类所具有的成员变量和方法；•在运行时调用任意一个对象的方法；•生成动态代理。

反射机制的相关API**InterFace **接口package com.app;public interface InterFace {void read() ;}Person 类package com.app;public class Person implements InterFace {private String id ;private String name ;public String age ;//构造函数1public Person( ){}//构造函数2public Person( String id ){this.id = id ;}//构造函数3public Person( String id , String name ){this.id = id ;this.nam e = name ;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}/*** 静态方法*/public static void update(){}@Overridepublic void read() {}}•获取类：3种方法package com.app;public class T1 {public static void main(Str ing[] args) {//第一种方法：forNametry {Class<?> class1 = Class.forName("com.app.Person");System.out.println( class1 );} catch (ClassNotFoundException e) {e.printStackTrace();}//第二张方法：classClass<?> class2 = Person.class;//第三种方法：getClassPerson person = new Person();Class<?> class3 = person.getClass();System.out.println( class2 );System.out.println( class3 );}}运行结果：class com.app.Personclass com.app.Personclass com.app.Pe rson•获取所有的方法：getMethods( )package com.app;import ng.reflect.Method;public cla ss T1 {public static void main(String[] args) {try {//创建类Class<?> class1 = Class.forName("com.app.Person");//获取所有的公共的方法Method[] methods = class1.getMethods() ;for (Method method : methods) {System.out.println( method );}} catch (ClassNotFoundException e) {e.printStackTrace();}}}运行结果：//自定义方法public static void com.app.Person.update()public ng.Strin g com.app.Person.getName()public void com.app.Person.read()public ng.String com.app.Person.getId()public void com.a pp.Person.setName(ng.String)public void com.app.Person .setId(ng.String)//父类Object类方法public final void ng.Object.wait() throws ng.Interrup tedExceptionpublic final void ng.Object.wait(long,int) thro ws ng.InterruptedExceptionpublic final native void n g.Object.wait(long) throws ng.InterruptedExceptionpublic boolean ng.Object.equals(ng.Object)public n g.String ng.Object.toString()public native int ng.Obj ect.hashCode()public final native ng.Class ng.Object .getClass()public final native void ng.Object.notify()public final native void ng.Object.notifyAll()•获取所有实现的接口：getInterfaces()package com.app;public class T1 {public static void main(Str ing[] args) {try {//创建类Class<?> class1 = Class.forName("com.app.Person");//获取所有的接口Class<?>[] interS = class1.getInterfaces() ;for (Class<?> clas s2 : interS ) {System.out.println( class2 );}} catch (ClassNotFoundException e) {e.printStackTrace();}}}运行结果：interface com.app.InterFace•获取父类：getSuperclass()package com.app;public class T1 {public static void main(Str ing[] args) {try {//创建类Class<?> class1 = Class.forName("com.app.Person");//获取父类Class<?> superclass = class1.getSuperclass() ;System.out.println( superclass );} catch (ClassNotFoundException e) {e.printStackTrace();}}}运行结果：//父类是Object类class ng.Object•获取所有的构造函数：getConstructors()package com.app;import ng.reflect.Constructor;public class T1 {public static void main(String[] args) {try {//创建类Class<?> class1 = Class.forName("com.app.Person");//获取所有的构造函数Constructor<?>[] constructors = class1.getConstructors() ;f or (Constructor<?> constructor : constructors) {System.out.println( constructor );}} catch (ClassNotFoundException e) {e.printStackTrace();}}}运行结果：public com.app.Person(ng.String,ng.String)publ ic com.app.Person(ng.String)public com.app.Person()•获取所有的属性：getDeclaredFields();package com.app;import ng.reflect.Constructor;impor t ng.reflect.Field;public class T1 {public static void main(St ring[] args) {try {//创建类Class<?> class1 = Class.forName("com.app.Person");//取得本类的全部属性Field[] field = class1.getDeclaredFields();for (Field field2 : fiel d) {System.out.println( field2 );}} catch (ClassNotFoundException e) {e.printStackTrace();}}}运行结果：private ng.String com.app.Person.idprivate ng.S tring 可以看出属性的修饰符是: private , 数据类型：String ，名字：id/name•创建实例：newInstance()package com.app;public class T1 {public static void main(Str ing[] args) {try {//创建类Class<?> class1 = Class.forName("com.app.Person");;//创建实例化：相当于 new 了一个对象Object object = class1.newInstance() ;//向下转型Person person = (Person) object ;} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}}}getDeclaredFields 和 getFields 的区别getDeclaredFields()获得某个类的所有申明的字段，即包括public、private和proteced，但是不包括父类的申明字段。

Java反射机制学习总结

Java反射机制学习总结Java反射机制学习总结一、什么是反射机制简单的来说，反射机制指的是程序在运行时能够获取自身的信息。

在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。

二、哪里用到反射机制有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成驱动对象实例，并不知道它的具体含义。

听了反射机制这节课后，才知道，原来这就是反射，现在很多开框架都用到反射机制，hibernate、struts都是用反射机制实现的。

三、反射机制的优点与缺点为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，静态编译：在编译时确定类型，绑定对象,即通过。

动态编译：运行时确定类型，绑定对象。

动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。

一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。

比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。

采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。

它的缺点是对性能有影响。

使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。

这类操作总是慢于只直接执行相同的操作。

四、利用反射机制能获得什么信息一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了首先得根据传入的类的全名来创建Class对象。

java学习笔记反射机制

java学习笔记09--反射机制什么是反射：反射是java语言的一个特性，它允许程序在运行时来进行自我检查并且对内部的成员进行操作。

例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。

java的反射机制的实现要借助4个类：Class,Constructor,Field,Method 其中Class代表的是类对象，Constructor 类的构造器对象，Field 类的属性对象，Method类的方法对象。

通过这四个对象我们可以粗略的看到一个类的各个组成部分。

在正常情况下，必须知道一个类的完整路径之后才可以实例化对象，但是在java中也允许通过一个对象来找到其所在的类的信息，那么这实际上就是Class类的功能。

package com.itmyhome;class A{}public class T {public static void main(String[] args) {// TODO Auto-generated method stubA a = new A();System.out.println(a.getClass().getName()); //com.itmyhome.A}}Object类的支持在Object类中定义了以下的方法，此方法将被所有子类继承：public final Class getClass()以上的方法返回值的类型是一个"Class"类，实际上此类是java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即:可以通过对象反射求出类的名称。

Class类Class本身表示一个类的本身，通过Class可以完整的得到一个类中的完整结构，包括此类中的方法定义，属性定义等。

实例化Class类对象有三种方法实例化Class对象：第一种：通过forName()方法第二种：类.class第三种：对象.getClass()package com.itmyhome;class A{}public class T {public static void main(String[] args) throws ClassNotFoundException {// TODO Auto-generated method stubClass<?> c1 = Class.forName("com.itmyhome.A");Class<?> c2 = A.class;Class<?> c3 = new A().getClass();System.out.println(c1.getName());System.out.println(c2.getName());System.out.println(c3.getName());}}Class主要是反射的源头，不光可以取得对象所在类的信息，也可以直接通过Class类的方法进行对象的实例化操作正常情况下，使用关键字new为对象实例化，如果现在已经实例化好了Class对象，则就可以通过Class类中提供的实例化对象package com.itmyhome;class Person {private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String toString() {// TODO Auto-generated method stubreturn "name: " + name + ",age: " + age;}}public class T {public static void main(String[] args) throws ClassNotFoundException {Class<?> c = Class.forName("com.itmyhome.Person");Person person = null;try {person = (Person) c.newInstance(); //实例化对象} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}person.setName("itmyhome");person.setAge(23);System.out.println(person);}}通过以上的代码，可以发现，即使不使用关键字new对象也可以进行实例化操作，反射的作用。

Java——反射的意义及优缺点

Java——反射的意义及优缺点意义：1.增加程序的灵活性，避免将程序写死到代码里。

例：定义了一个接口，实现这个接口的类有20个，程序里用到了这个实现类的地方有好多地方，如果不使用配置文件手写的话，代码的改动量很大，因为每个地方都要改而且不容易定位，如果你在编写之前先将接口与实现类的写在配置文件里，下次只需改配置文件，利用反射（java API已经封装好了，直接用就可以用Class.newInstance()）就可完成。

2.代码简洁，提高代码的复用率，外部调用方便1.package cn.yonyong.reflection.testdemo;2.3.interface Fruit { //水果接口4.public void eat() ; //吃水果5.}6.7.class Apple implements Fruit{ //定义苹果8.public void eat() {9.System.out.println('**吃苹果。

');10.}11.}12.13.class Orange implements Fruit{14.public void eat() {15.System.out.println('**吃橘子。

');16.}17.}18.19.class Factory{20.public static Fruit getInstance(String className){21.Fruit fruit = null ;22.try{23.fruit = (Fruit) Class.forName(className).newInstance() ;24.}catch(Exception e ){25. e.printStackTrace() ;26.}27.return fruit ;28.}29.}30.31.public class FactoryDemo{32.public static void main(String args[]){33.//通过工厂类取得接口实例，传入完整的包.类名称34.Fruit f = Factory.getInstance('cn.yonyong.reflection.testdemo.Apple') ;35.if(f!=null){ //判断是否取得接口实例36. f.eat() ;37.}38.}39.}如果不用反射，那么我们如果再加一个西瓜类，就得在Factory里判断，每添加一个类都要修改一次Factory，但用了反射只用在调用的时候传入完整的类名就可完成。

Java反射机制的安全性问题

Java反射机制的安全性问题引言Java反射机制是一种强大的工具，它允许程序在运行时动态地加载、检查和使用类、方法和字段。

它为Java开发人员提供了很多灵活性和便利性，但是同时也带来了一些安全性问题。

本文将探讨Java反射机制的安全性问题，并提供一些建议来减轻这些风险。

1. 什么是Java反射机制Java反射机制是指在运行时动态地获取类的信息和操作类的成员。

通过反射机制，我们可以在运行时创建对象、调用方法、获取和修改字段的值等。

反射机制是Java语言的一个重要特性，广泛应用于框架和库的开发中。

2. Java反射机制的安全性问题尽管Java反射机制提供了很多便利，但它也带来了一些安全性问题。

下面是一些常见的安全风险：2.1 暴露私有成员反射机制可以绕过访问修饰符的限制，可以访问和修改类的私有成员。

这意味着，如果一个类中包含了敏感信息，通过反射机制可以轻松地获取和修改这些信息，造成安全漏洞。

例如，一个类中包含了数据库连接信息，正常情况下这些信息应该是私有的，但通过反射机制，可以获取到这些信息，从而可能导致数据库被非法访问。

2.2 突破访问控制反射机制可以绕过Java的访问控制机制，例如私有构造函数、静态块等。

这意味着，通过反射机制，可以创建私有构造函数的实例，调用私有方法和字段，突破了原本的访问限制。

这种行为可能会导致程序的不稳定性和安全性问题。

例如，一个类中包含了一些敏感操作，通过反射机制调用这些操作，可能导致程序的不可预料的行为。

2.3 代码注入反射机制可以动态地加载和执行代码，这可能导致代码注入的风险。

恶意用户可以利用反射机制，动态地加载恶意代码并执行，从而造成安全漏洞。

例如，一个Web应用程序使用反射机制动态地加载插件，如果没有对动态加载的代码进行严格的过滤和校验，就可能导致恶意代码的注入，进而导致系统被攻击。

3. 如何减轻Java反射机制的安全风险尽管Java反射机制存在一些安全风险，但我们可以采取一些措施来减轻这些风险。

对java反射的理解

对java反射的理解
Java反射是指在Java运行时环境中，通过程序分析其他程序的能力。

在Java中，我们可以通过反射机制获取类的信息，创建类的对象，调用类的方法，修改类的属性等。

Java反射机制是Java语言的一种动态性特征，使得Java程序具备了更高的灵活性和可扩展性。

Java反射机制实现主要依赖于ng.reflect包下的类，例如Class、Method、Field等。

其中Class类表示一个类的类型，Method类表示一个类的方法，Field类表示一个类的属性。

通过反射机制，我们可以动态地获取类的信息。

例如，我们可以通过Class类的forName()方法获取一个类的Class对象，再通过Class对象的getMethods()方法获取一个类的所有公共方法，通过getFields()方法可以获取一个类的所有公共属性，通过getMethod()方法和invoke()方法可以调用一个类的方法等。

在实际应用中，反射机制通常用于框架和工具的开发，例如Spring框架中的BeanFactory就是基于反射机制实现的。

但是需要注意的是，反射机制的使用比较消耗资源，且容易导致程序出错，因此在实际开发中应该慎重使用。

- 1 -。

java注解和反射实训结论

java注解和反射实训结论
在进行java注解和反射实训后，我们得出以下结论：
1. Java注解是在代码层面上的标记，在运行时不会影响程序的实际逻辑，但是可以通过反射获取注解信息，从而根据注解信息进行特定的处理。

2. Java反射可以在运行时获取类的信息，包括类名、字段、方法和注解等，然后可以根据这些信息进行特定的处理，比如动态创建对象、调用方法等。

3. 在实际应用中，Java注解和反射可以结合使用，通过注解标记特定的类、字段、方法等信息，然后使用反射获取这些信息并进行特定的处理，从而达到自动化的目的。

4. Java注解和反射的应用在企业级应用中非常广泛，比如Spring框架就大量使用了注解和反射，从而实现了自动化的配置、依赖注入等功能。

总之，Java注解和反射是Java语言中非常重要的特性，它们可以帮助我们实现自动化的目的，提高开发效率和代码质量。

- 1 -。