Java高级程序设计实战教程第三章 Java反射机制
Java中的反射机制详解
Java中的反射机制详解Java作为一种编程语言，具有许多强大的特性和功能。
其中，反射机制是其中的重要部分之一。
通过反射机制，Java程序可以在运行时动态地获取类的信息、构造对象、调用方法和访问属性等。
本文将详细介绍Java中的反射机制。
一、什么是反射机制？Java中的反射机制指的是在程序运行时动态获取类的信息并对其进行操作的能力。
通过反射机制，Java程序可以在运行时获取类的属性、方法和构造器等信息，并对其进行操作。
利用反射机制可以实现动态代理、框架开发、自动化测试等功能。
二、反射机制的基本原理Java程序在编译时会将类的信息编译成.class文件。
在程序运行时，JVM会将.class文件加载到内存中，并生成一个Class对象，该对象包含了类的所有信息。
通过Class对象，Java程序可以获取类的构造器、方法、属性等信息，并对它们进行操作。
三、反射机制的使用Java中的反射机制主要通过ng.reflect包中的类和接口实现。
在这个包中，最常用的类包括Class、Constructor、Method和Field等。
下面我们将分别介绍这些类的用法。
1、Class类Class类是Java中用来表示类的类。
在Java程序中，每个类都有一个对应的Class对象，可以使用该对象获取类的信息。
获取Class对象有以下三种方式：（1）使用类的.class属性获取：Class clazz = MyClass.class;（2）使用Class的forName()方法获取：Class clazz = Class.forName("com.example.MyClass");（3）使用对象的getClass()方法获取：MyClass obj = new MyClass();Class clazz = obj.getClass();通过Class对象可以获取类的信息，如：（1）类的名称：String name = clazz.getName(); // com.example.MyClass（2）类的简单名称：String simpleName = clazz.getSimpleName(); // MyClass（3）类的包路径：Package pkg = clazz.getPackage(); // com.example（4）类的修饰符：int modifiers = clazz.getModifiers(); // 返回访问修饰符列表（5）类的父类：Class superClass = clazz.getSuperclass(); // 返回父类的Class对象2、Constructor类Constructor类用于描述类的构造器。
JAVA反射机制详解
反射概述1反射的概述1.1什么是反射每个.class文件被加载到内存后都是一个Class类的对象！例如Demo.class加载到内存后它是Class<Demo>类型的一个对象。
反射就是通过Class对象获取类型相关的信息。
一个Class对象就表示一个.class文件，可以通过Class对象获取这个类的构造器、方法，以及成员变量等。
反射是Java的高级特性，在框架中大量被使用！我们必须要了解反射，不然无法学好JavaWeb 相关的知识！1.2反射相关类与反射相关的类：●Class：表示类；●Field：表示成员变量；●Method：表示方法；●Constructor：表示构造器。
2Class类2.1获取Class类获取Class类的三种基本方式：●通过类名称.class，对基本类型也支持；Class c = int.class；Class c = int[].class；Class c = String.class●通过对象.getClass()方法Class c = obj.getClass();●Class.forName()通过类名称加载类，这种方法只要有类名称就可以得到Class；Class c = Class.forName(“cn.itcast.Demo”);2.2Class类的常用方法●String getName()：获取类名称，包含包名；●String getSimpleName()：获取类名称，不包含包名；●Class getSupperClass()：获取父类的Class，例如：new Integer(100).getClass().getSupperClass()返回的是Class<Number>！但new Object().getSupperClass()返回的是null，因为Object没有父类；●T newInstance()：使用本类无参构造器来创建本类对象；●boolean isArray()：是否为数组类型；●boolean isAnnotation()：是否为注解类型；●boolean isAnnotationPresent(Class annotationClass)：当前类是否被annotationClass注解了；●boolean isEnum()：是否为枚举类型；●boolean isInterface()：是否为接口类型；●boolean isPrimitive()：是否为基本类型；●boolean isSynthetic()：是否为引用类型；2.3通过反射创建对象3ConstructorConstructor表示一个类的构造器。
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出新的对象是都会执行，等同于构造方法中的语句。
java反射的实现原理
java反射的实现原理Java反射的实现原理什么是反射反射是指在运行时动态地获取并操作类或对象的信息的一种机制。
通过反射，我们可以在程序运行时获得类的属性、方法、构造函数等，并能够动态调用这些方法，创建对象实例。
反射的基本原理Java反射的实现原理主要涉及到以下几个关键概念：Class 对象在Java中，每个类都有一个对应的Class对象，它保存了该类的结构信息。
Class对象是Java反射的起点，可以通过多种方式获取到一个类的Class对象。
()() 方法是获取一个类的Class对象的常用方式。
该方法接收一个类的全限定名作为参数，通过类加载器加载对应的类，并返回该类的Class对象。
实例化对象通过获取到Class对象，我们可以使用它来创建类的实例。
Class 对象提供了几个用于实例化对象的方法，如newInstance()方法可以创建一个类的实例。
获取字段信息通过Class对象，可以获取到类中定义的字段信息。
getField()方法可以获取到公有的字段，而getDeclaredField()方法可以获取到所有的字段，包括公有和私有的。
获取方法信息同样地，Class对象也可以获取到类中定义的方法信息。
getMethod()方法可以获取到公有的方法，而getDeclaredMethod()方法可以获取到所有的方法，包括公有和私有的。
类型转换获取到字段或方法后，可以进一步获取其类型信息，并进行类型转换。
通过Field类的get()方法，我们可以获取到字段的值，并根据需要进行类型转换。
同样地，通过Method类的invoke()方法，可以调用方法并获取返回值，并进行类型转换。
反射的应用场景反射在Java开发中有着广泛的应用场景：1.动态代理：通过反射可以实现代理模式，对目标对象进行增强处理。
2.框架开发：许多开源框架如Spring、Hibernate等都大量使用了反射机制，以实现灵活的配置和扩展。
3.序列化与反序列化：反射可以在对象的持久化和还原过程中，动态地获取对象的属性并进行操作。
Java中的反射机制及其在AOP中的应用
反射机制及其在Java中的应用简介反射机制是Java语言的一项重要特性，它允许程序在运行时获取一个类的信息，并通过这些信息动态地操作对象。
它提供了一种强大的能力，可以实现一些在编译时无法预知的操作。
在本文中，我们将深入探讨Java中的反射机制，并探讨其在面向切面编程（AOP）中的应用。
反射机制的基本概念类加载器在讨论反射机制之前，我们需要了解Java中的类加载器。
类加载器负责将类的字节码文件加载到内存中，并生成对应的Class对象。
Java中存在多个层次的类加载器，每个类加载器负责加载特定的类。
具体的类加载器层次结构可以用一棵树来表示，根加载器（Bootstrap Class Loader）位于树的最顶层，它加载核心类库。
其他的类加载器（如扩展类加载器、应用程序类加载器）则分别加载扩展类和应用程序类。
Class对象Class对象是反射机制的核心，它代表一个类的实例。
在Java中，每个类都有一个对应的Class对象，并且在程序运行期间只会加载一次。
通过Class对象，我们可以获取类的属性、方法和构造函数等信息，并对其进行动态操作。
反射APIJava提供了一系列的反射API，用于操作Class对象和对象实例。
这些API包括了获取类的信息、创建对象实例、调用方法和获取/设置属性等功能。
反射机制的应用动态加载类通过反射机制，我们可以在运行时动态地加载一个类。
这对于需要根据条件来选择不同的实现类的场景非常有用。
通过Class.forName()方法，我们可以根据类的全限定名来加载一个类，并获取对应的Class对象。
Class<?> clazz = Class.forName("com.example.MyClass");实例化对象反射机制可以在运行时动态地实例化一个对象。
通过Class对象的newInstance()方法，我们可以创建一个对象实例。
Class<?> clazz = MyClass.class;Object obj = clazz.newInstance();调用方法反射机制提供了强大的功能来调用对象的方法。
java反射的原理
java反射的原理Java反射的原理。
Java反射是指在程序运行时，可以动态地获取类的信息、调用类的方法、操作类的属性等能力。
它使得程序可以在运行时获取类的信息，并且可以动态地创建对象、调用方法、访问属性，而不需要在编译时就确定这些信息。
Java反射的原理可以简单地概括为通过一个类加载器将Java类加载到JVM中，然后通过类加载器获取类的信息，包括类的属性、方法、构造器等，最后通过这些信息来实现对类的操作。
首先，Java反射的原理涉及到类加载器。
类加载器负责将Java类加载到JVM 中，并在程序运行时动态创建类的实例。
在Java中，类加载器分为三种，启动类加载器、扩展类加载器和应用程序类加载器。
启动类加载器负责加载JRE中的核心类库，扩展类加载器负责加载JRE扩展目录中的类库，而应用程序类加载器负责加载应用程序的类。
其次，Java反射的原理涉及到Class类。
在Java中，每个类都会被对应的Class对象所表示，这个Class对象包含了类的所有信息，包括类的属性、方法、构造器等。
通过这个Class对象，程序可以在运行时获取类的信息，并且可以动态地创建对象、调用方法、访问属性。
然后，Java反射的原理还涉及到反射API。
Java提供了一套反射API，包括Class类、Field类、Method类、Constructor类等，通过这些类可以实现对类的操作。
比如，通过Class类可以获取类的信息，通过Field类可以操作类的属性，通过Method类可以调用类的方法，通过Constructor类可以创建类的实例。
最后，Java反射的原理还涉及到动态代理。
动态代理是指在运行时动态地创建一个代理类，这个代理类实现了指定的接口，并且可以在运行时处理方法的调用。
Java反射可以通过动态代理来实现一些高级的功能，比如AOP（面向切面编程）和RPC（远程过程调用）等。
总的来说，Java反射的原理是通过类加载器将Java类加载到JVM中，然后通过Class类获取类的信息，再通过反射API实现对类的操作，最后通过动态代理来实现一些高级的功能。
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的反射机制》PPT课件
三种方式：
(1) 对象名.getClass() Person p1=new Person(); p1.getClass();
(2)类名.class Date.class
(3) Class.forName()方法 (此方式用的较多) Class.forName(“ng.String”);
精选ppt
10
Method类
Method用来表示类中的方法。通过Class对象的如下 方法得到Method对象
Method getMethod(String name, Class<?>... parameterTypes) 按名称得到某个特定的public方法(包括从父类或接口继承的方法)
Method[] getMethods() 得到public方法(包括从父类或接口继承的方法)
见源文件：Field/FieldTest.java
精选ppt
9
Field类
练习：扫描一个对象中所有的字符串类型的 属性，并为每一个字符串属性的值后面添加 “hello”字符串，然后将这个对象输出。
见源文件：Field/FieldTest1.java
注意：对于字节码的比较一定要用“= =”，而不是equals()。 掌握上述例子对于理解Spring等框架技术具有重要作用。
int.class==Integer.TYPE
void.class==Void.TYPE
精选ppt
5
反射(Reflect)
反射就是把Java类中的各个组成部分映射成相应的 Java类。
一个类的组成部分包括：属性、方法、构造方法、包等。这些 组成部分都会被映射成相应的类。
Java反射机制
�示例：获得类中所有的方法信息
.*; import ng.reflect ng.reflect. public class Test { private int method(Object p, int x) throws NullPointerException { if (p == null ) null) (); throw new NullPointerException NullPointerException(); return x; } []) { public static void main(String args args[]) try { ("Test" ); Class cls = Class.forName forName( "Test"); [] = cls.getDeclaredMethods (); Method methlist methlist[] cls.getDeclaredMethods(); int i = 0; i < methlist. length ; i++) { for ( (int methlist.length length; Method m = methlist [i]; methlist[i]; .println ("name = " + m.getName ()); System.out out.println .println( m.getName()); System.out .println ("decl class = " + m.getDeclaringClass ()); out.println .println( m.getDeclaringClass()); [] = m.getParameterTypes (); Class pvec pvec[] m.getParameterTypes(); int j = 0; j < pvec. length ; j++) for ( (int pvec.length length; .println ("param #" + j + " " + pvec [j]); System.out out.println .println( pvec[j]); [] = m.getExceptionTypes (); Class evec evec[] m.getExceptionTypes(); int j = 0; j < evec. length ; j++) for ( (int evec.length length; System.out .println ("exc #" + j + " " + evec [j]); out.println .println( evec[j]); .println ("return type = " + m.getReturnType ()); System.out out.println .println( m.getReturnType()); .println ("-----" ); System.out out.println .println( "-----"); } Throwable e){ } catch ( (Throwable System.err .println(e); err.println(e); } } }
高级java机视笔试题及答案
高级java机视笔试题及答案# 高级Java机试题目及答案题目1：Java反射机制问题：请简述Java反射机制的作用，并给出一个使用反射机制创建对象的示例代码。
答案：Java反射机制允许程序在运行时访问、检查和修改它自己的结构，包括类、接口、字段和方法。
它使得Java程序可以在运行时创建对象、调用方法、修改字段等。
示例代码：```javaClass<?> clazz = Class.forName("ng.String"); Constructor<?> constructor =clazz.getConstructor(String.class);Object obj = constructor.newInstance("Hello, World!"); System.out.println(obj);```题目2：Java多线程问题：请解释Java中实现多线程的两种主要方式，并给出各自实现的示例代码。
答案：Java实现多线程有两种主要方式：继承Thread类和实现Runnable接口。
继承Thread类示例代码：```javaclass MyThread extends Thread {public void run() {System.out.println("Thread is running.");}}public class Main {public static void main(String[] args) {MyThread myThread = new MyThread();myThread.start();}}```实现Runnable接口示例代码：```javaclass MyRunnable implements Runnable {public void run() {System.out.println("Thread is running.");}}public class Main {public static void main(String[] args) {Thread thread = new Thread(new MyRunnable());thread.start();}}```题目3：Java集合框架问题：请解释Java集合框架中的List、Set和Map的区别，并给出各自的使用场景。
JAVA反射概念及使用详解（超详细）
JAVA反射概念及使⽤详解（超详细）JAVA反射概念及使⽤详解⼀、什么是反射？反射：框架设计的灵魂框架：半成品软件。
可以在框架的基础上进⾏软件开发，简化编码反射：将类的各个组成部分封装为其他对象，这就是反射机制好处：可以在程序运⾏过程中，操作这些对象。
可以解耦，提⾼程序的可扩展性。
图⽚来源https:///qsbbl/article/details/85801571定义：JAVA反射机制是在运⾏状态中，对于任意⼀个类，都能够知道这个类的所有属性和⽅法；对于任意⼀个对象，都能够调⽤它的任意⼀个⽅法，这种动态获取、调⽤对象⽅法的功能称为java语⾔的反射机制。
反射是通过Class对象(字节码⽂件)，来知道某个类的所有属性和⽅法。
也就是说通过反射我们可以获取构造器，对象，属性，⽅法（原本不知道）不像现在这个类我们能看见，之后在JAVA框架中，很多类我们是看不见的，不能直接⽤类名去获取对象，只能通过反射去获取。
图⽚来源https:///sinat_38259539/article/details/71799078⼆、获取Class对象的三种⽅式：要想使⽤反射，必须先得到代表的字节码的Class对象，Class类⽤于表⽰.class⽂件（字节码）1.通过该类的对象去获取到对应的Class对象（基本不⽤它）//第⼀种⽅式: student--->Class对象通过getClass()⽅法//Student是⼀个空类Student student = new Student();//这⾥我们就省去泛型了，Class<?>Class stuClass = student.getClass(); //获取到了对应的Class对象System.out.println(stuClass);System.out.println(stuClass.getName()); //获取Class对象的名字输出：class fanshe.Studentfanshe.Student但是需要注意的是，第⼀种我们基本不⽤，这⾥显然和反射机制相悖（你有类对象 student 还去⽤反射获取Class类对象⼲嘛，多此⼀举）2.通过类名.class静态属性获取（⽐较简单）//第⼆种⽅式: 每个类创建后都会有⼀个默认的静态的class属性⽤于返回该类的class对象//需要注意的是: 任何数据类型（包括基本数据类型）都有“静态”的class属性Class stuClass2 = Student.class;System.out.println("是否为同⼀个class对象?"+(stuClass==stuClass2));结果：true这⾥需要注意的是，这种⽅式虽然⽐较简单，但是需要导包，不然会编译错误（对⽐第三种，全限定类名⽅式）3.通过Class类中的静态⽅法 forName()⽅法获取（最为常见）//第三种⽅式: Class.forName("fanshe.Student"); 注意参数⼀定为该类的全限定类名try {Class stuClass3 = Class.forName("fanshe.Student");//System.out.println(stuClass3); 输出仍然是class fanshe.StudentSystem.out.println("是否为同⼀个class对象?"+(stuClass3==stuClass2));} catch (ClassNotFoundException e) {e.printStackTrace();}结果：true结论：同⼀个字节码⽂件(*.class)在⼀次程序运⾏过程中，只会被加载⼀次，不论通过哪⼀种⽅式获取的Class对象都是同⼀个。
java反射机制8页word文档
Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。
灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。
那么什么是Java的反射呢？大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。
Java类如果不被Java虚拟机加载，是不能正常运行的。
现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。
Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。
使用在编译期并不知道的类。
这样的特点就是反射。
那么Java反射有什么作用呢？假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。
那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。
利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。
大家都用过Jcreator和eclipse。
当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。
一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。
这就是利用了Java反射的原理，是对我们创建对象的探知、自审。
Class类要正确使用Java反射机制就得使用ng.Class这个类。
它是Java反射机制的起源。
当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。
通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。
反射API◆反射API用于反应在当前Java虚拟机中的类、接口或者对象信息◆功能—获取一个对象的类信息.—获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.—检获属于一个接口的常量和方法声明.—创建一个直到程序运行期间才知道名字的类的实例.—获取并设置一个对象的成员，甚至这个成员的名字是在程序运行期间才知道.—检测一个在运行期间才知道名字的对象的方法利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。
Java高级程序设计实战教程第三章 Java反射机制
3.7 课后习题
三、简答题 1.描述反射机制的作用。举几个反射的应用。 2.简述Java反射中API的主要类及作用。 3.简述Java反射的步骤。
3.8 上机实训
实训 从配置文件中读取类，并显示其构造函数。 配置文件 config.properties
Java高级程序设计
第3章 Java反射机制
3.1 应用场景 3.3 实施过程 3.5 拓展训练 3.7 课后习题
3.2 相关知识 3.4 拓展知识 3.6 课后小结 3.8 上机实训
3.1 应用场景
在一些开源框架里，如Spring，Struts，Hibernate，MyBatis等，应用程序会 提供一个配置文件如xml文件或者properties，然后在Java类里面解析xml或 properties里面的内容，得到一个字符串，然后用反射机制，根据这个字符串 获得某个类的Class实例，这样就可以动态配置一些东西，不用每一次都要在 代码里面去new或者做其他的事情，以后要改的话直接改配置文件，代码维护 起来就很方便了，同时有时候要适应某些需求，Java类里面不一定能直接调 用另外的方法，这时候也可以通过反射机制来实现。 应用程序通过读取配置文件来获取到指定名称的类的字节码文件并加载其中 的内容进行调用，对一个类文件进行解剖，就可以取得任意一个已知名称的 class的内部信息，包括其modifiers（诸如public，static等等）、superclass （例如Object）、实现之interfaces（例如Serializable），也包括fields和 methods的所有信息，并可于运行时改变fields内容或调用methods。
缺点：性能是一个问题，反射相当于一系列解释操作，通知jvm要做的事情，性能 比直接的Java代码要慢很多。
JAVA高级工程师 精讲反射 底层代码
反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。
通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。
下面具体介绍一下java的反射机制。
这里你将颠覆原来对java的理解。
Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的是类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。
通过这四个对象我们可以粗略的看到一个类的各个组成部分。
Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。
这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。
但是这些信息我们怎么得到啊，就要借助于class 类对象了啊。
在Object类中定义了getClass()方法。
我们可以通过这个方法获得指定对象的类对象。
然后我们通过分析这个对象就可以得到我们要的信息了。
比如：ArrayList arrayList;Class clazz = arrayList.getClass();然后我来处理这个对象clazz。
当然了Class类具有很多的方法，这里重点将和Constructor，Field，Method类有关系的方法。
Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。
Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。
1．检测类：reflection的工作机制考虑下面这个简单的例子，让我们看看reflection 是如何工作的。
import ng.reflect.*;public class DumpMethods {public static void main(String args[]) {try {Class c = Class.forName(args[0]);Method m[] = c.getDeclaredMethods();for (int i = 0; i < m.length; i++)System.out.println(m[i].toString());} catch (Throwable e) {System.err.println(e);}}}按如下语句执行：java DumpMethods java.util.ArrayList这个程序使用Class.forName 载入指定的类，然后调用getDeclaredMethods 来获取这个类中定义了的方法列表。
Java程序设计教程课件：Java高级编程
12.2 Annotation
在反射机制中经常用到的Package、Class、Field、 Method等类都实现了AnnotatedElement接口，因此这些 类的对象可以利用实现的接口方法获取在其上添加的 Annotation信息，执行编写的相关Annotation内容所设定 的操作。这些操作均是Java编译器在进行源程序编译的过程 中完成的，使得程序在进行编译和之后的解释、运行过程中 ，不仅执行源程序原有的内容，还将执行Annotation指定 的操作，增强了源程序的功能。
12.2 Annotation
在这个接口中，定义了四个方法： public Annotation getAnnotation(Class
annotationType) 返回为当前对象添加的annotationType 类型的注释对象 public Annotation[ ] getAnnotations( ) 返回为当前对象 添加的所有注释对象 public Annotation[ ] getDeclaredAnnotations( ) 返回 为当前对象直接添加的所有注释对象，不包括继承的 Annotation public boolean isAnnotationPresent(Class annotationType) 判断当前 对象上是否添加了参数annotationType指定的注释，如果添 加了，返回true，否则，返回false
▪ @Annotation名称
(param1=value1,param2={value2,value3, ……})
▪ @Annotation名称({value1,value1, ……}) ▪ @Annotation名称(唯一参数值) ▪ @Annotation名称
反射机制详解
反射机制详解一、了解什么是反射Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。
灵活掌握Java 反射机制可以帮助我们更好的认识Java，对于学习框架，自己构建框架的帮助也非常大。
那么，对于反射我们怎么定义呢？Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。
使用在编译期并不知道的类。
这样的特点就是反射。
在运行时期,动态地去获取类中的信息(类的信息,方法信息,构造器信息,字段等信息);对我们来说，反射就是拿到运行期的类的对象，然后这个类的对象中可以拿到这个类的所有信息(类名，构造器，方法，字段等)二、反射的作用1、增加程序的灵活性，避免将程序写死到代码里(解除硬编码的问题)2、Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力。
当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。
一按点，编译工具(Eclipse)就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。
这就是利用了Java反射的原理，是对我们创建对象的探知、自审。
3、可以让程序员在不知道其它程序员会有什么类的时候就编写完成自己的代码(对框架来说这是非常有必要的)当然，反射也有它自己的问题：如它会破坏封装(因为反射可以拿到私有的构造器与方法，并且创建执行)，还会影响性能(直接创建对象当然比通过反射创建对象速度更快)。
三、怎么使用反射如果要学习反射，我们可以在java的api中找到ng.reflect这个包，反射的所有要使用的类都在这个包中。
由于反射是动态拿到一个类的基本结构信息。
因此咱们要使用反射，首先得确定你要拿哪一个类，然后拿到这个类的类对象(即class对象)。
下图为api中对Class类的解释：注意：当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM 便自动产生一个Class 对象。
JAVA中的反射机制
JAVA中的反射机制一，先看一下反射的概念：主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
反射是java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。
但是反射使用不当会成本很高！看概念很晕的，继续往下看。
二，反射机制的作用：1，反编译：.class-->.java2,通过反射机制访问java对象的属性，方法，构造方法等；这样好像更容易理解一些，下边我们具体看怎么实现这些功能。
三，在这里先看一下sun为我们提供了那些反射机制中的类：ng.Class;ng.reflect.Constructor; ng.reflect.Field;ng.reflect.Method;ng.reflect.Modifier;很多反射中的方法，属性等操作我们可以从这四个类中查询。
还是哪句话要学着不断的查询API，那才是我们最好的老师。
四，具体功能实现：1，反射机制获取类有三种方法，我们来获取Employee类型[java]view plain copy print?1.//第一种方式：2.Class c1 = Class.forName("Employee");3.//第二种方式：4.//java中每个类型都有class 属性.5.Class c2 = Employee.class;6.7.//第三种方式：8.//java语言中任何一个java对象都有getClass 方法9.Employee e = new Employee();10.Class c3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) 2，创建对象：获取类以后我们来创建它的对象，利用newInstance：1.Class c =Class.forName("Employee");2.3.//创建此Class 对象所表示的类的一个新实例4.Objecto = c.newInstance(); //调用了Employee的无参数构造方法. 3,获取属性：分为所有的属性和指定的属性：a，先看获取所有的属性的写法：1.//获取整个类2. Class c = Class.forName("ng.Integer");3.//获取所有的属性?4. Field[] fs = c.getDeclaredFields();5.6.//定义可变长的字符串，用来存储属性7. StringBuffer sb = new StringBuffer();8.//通过追加的方法，将每个属性拼接到此字符串中9.//最外边的public定义10. sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");11.//里边的每一个属性12.for(Field field:fs){13. sb.append("\t");//空格14. sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等15. sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字16. sb.append(field.getName()+";\n");//属性的名字+回车17. }18.19. sb.append("}");20.21. System.out.println(sb);b，获取特定的属性，对比着传统的方法来学习：1.public static void main(String[] args) throws Exception{2.3.//以前的方式：4./*5. User u = new User();6. u.age = 12; //set7. System.out.println(u.age); //get8. */9.10.//获取类11. Class c = Class.forName("User");12.//获取id属性13. Field idF = c.getDeclaredField("id");14.//实例化这个类赋给o15. Object o = c.newInstance();16.//打破封装17. idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。
java 反射机制详解
前言，在Java运行时刻，能否知道一个类的属性方法并调用改动之？对于任意一个对象，能否知道他的所属类，并调用他的方法？答案是肯定的。
这种动态的获取信息及动态调用方法的机制在Java中称为“反射”（reflection）。
Java反射机制主要提供以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法。
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。
这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods 的所有信息，并可于运行时改变fields内容或调用methods。
一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。
在JDK中，主要由以下类来实现Java反射机制，这些类都位于ng.reflect包中：Class类：代表一个类；Field 类：代表类的成员变量（成员变量也称为类的属性）；Method类：代表类的方法；Constructor 类：代表类的构造方法；Array类：提供了动态创建数组，以及访问数组的元素的静态方法；例程DateMethodsTest类演示了Reflection API的基本作用，它读取命令行参数指定的类名，然后打印这个类所具有的方法信息，代码如下：Datemethodstest.java代码public class DateMethodsTest{public static void main(String args[]) throws Exception{// 加载并初始化命令行参数指定的类Class<?> classType = Class.forName("java.util.Date");// 获得类的所有方法Method methods[] = classType.getDeclaredMethods();for (int i = 0; i < methods.length; i++){System.out.println(methods[i].toString());}}}public class DateMethodsTest{public static void main(String args[]) throws Exception{// 加载并初始化命令行参数指定的类Class<?> classType = Class.forName("java.util.Date");// 获得类的所有方法Method methods[] = classType.getDeclaredMethods();for (int i = 0; i < methods.length; i++){System.out.println(methods[i].toString());}}}例程ReflectTester类进一步演示了Reflection API的基本使用方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
缺点：性能是一个问题，反射相当于一系列解释操作，通知jvm要做的事情，性能 比直接的Java代码要慢很多。
任务需求：设有一个类Person，使用反射机制获取该类的相关信息。 任务设计： 实体类Person，存放个人的基本信息，测试类TestPerson使用反射机制获取Person类或其对象的封装信息。其类图如图3-3-11所示。
3.2.2 反射机制的功能
反射机制的功能如下： 在运行时判定任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判定任意一个类所具有的成员变量和方法； 在运行时调用任意一个对象的方法； 生成动态代理；。
3.2.3 Java反射机制的相关API
ng.reflect包提供了用于获取类和对象的反射信息 的类和接口。反射API允许对程序访问有关加载类的字段，方 法和构造函数的信息进行编程访问。它允许在安全限制内使用 反射的字段，方法和构造函数对其底层对等进行操作。 ng.Class; //类 ng.reflect.Constructor;//构造方法 ng.reflect.Field; //类的成员变量 ng.reflect.Method;//类的方法 ng.reflect.Modifier;//访问权限
3.5 拓展训练
任务1 Java反射机制在工厂模式中的应用 先看简单工厂模式（simple factory）。 任务设计： 接口Car，类Benz，Bmw，Bike。更好的理解工厂设计模式 课后小结
1. 反射机制指的是程序在运行时能够获取自身的信息。在Jjava中，只要给定类的名字， 那么就可以通过反射机制来获得类的所有信息。 2. 现在很多开框架都用到反射机制，hibernate、struts都是用反射机制实现的。 3. 静态编译：在编译时确定类型，绑定对象,即通过。 动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了Jjava的灵活性，体 现了多态的应用，有以降低类之间的藕合性。一句话，反射机制的优点就是可以实现 动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表 现的十分明显。 4. 类中有什么信息，反射就可以获得什么信息，不过前提是得知道类的名字。 5. 有了Jjava反射机制，只需要写一个dao类，四个方法，增删改查，传入不同的对象， 无需为每一个表都创建dao类，反射机制会自动帮我们完成剩下的事情，反射机制就 是专门帮我们做那些重复的有规则的事情。
Java高级程序设计
第3章 Java反射机制
3.1 应用场景 3.3 实施过程 3.5 拓展训练 3.7 课后习题
3.2 相关知识 3.4 拓展知识 3.6 课后小结 3.8 上机实训
3.1 应用场景
在一些开源框架里，如Spring，Struts，Hibernate，MyBatis等，应用程序会 提供一个配置文件如xml文件或者properties，然后在Java类里面解析xml或 properties里面的内容，得到一个字符串，然后用反射机制，根据这个字符串 获得某个类的Class实例，这样就可以动态配置一些东西，不用每一次都要在 代码里面去new或者做其他的事情，以后要改的话直接改配置文件，代码维护 起来就很方便了，同时有时候要适应某些需求，Java类里面不一定能直接调 用另外的方法，这时候也可以通过反射机制来实现。 应用程序通过读取配置文件来获取到指定名称的类的字节码文件并加载其中 的内容进行调用，对一个类文件进行解剖，就可以取得任意一个已知名称的 class的内部信息，包括其modifiers（诸如public，static等等）、superclass （例如Object）、实现之interfaces（例如Serializable），也包括fields和 methods的所有信息，并可于运行时改变fields内容或调用methods。
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有
属性和方法；对于任意一个对象，都能够调用它的任意一个方法，常见的应用如下
逆向代码 ，例如反编译
与注解相结合的框架 例如Retrofit
单纯的反射机制应用框架 例如EventBus 2.x
动态生成类框架 例如Gson
3.2.6 反射机制的优缺点
3.2 相关知识
3.2.1 Java反射机制的概念 3.2.2 反射机制的功能 3.2.3 Java反射机制的相关API 3.2.4 使用反射机制的步骤 3.2.5 反射机制的应用场景 3.2.6 反射机制的优缺点
3.2.1 Java反射机制的概念
Java反射机制在Java运行状态中，对于任意一个类， 我们都能够知道这个类的所有属性和方法；， 对于任意一个对象，我们都能够调用它的任意一个方 法；。 这种动态获取的信息以及动态调用对象的方法的功能 称为Java语言的反射机制。
可以实现动态创建对象和编译，体现出很大的灵活性（特别是在J2EE的开发
中它的灵活性就表现的十分明显）。通过反射机制我们可以获得类的各种内容，进
行了反编译。对于JAVA这种先编译再运行的语言来说，反射机制可以使代码更加 灵活，更加容易实现面向对象,总结如下。
优点：运行期类型的判断，动态类加载，动态代理使用反射。
3.3 实施过程
任务需求：设有一个类Person，使用反射机制获取该类 的相关信息。 任务设计： 实体类Person，存放个人的基本信息，测试类 TestPerson使用反射机制获取Person类或其对象的封装 信息。其类图如图3-3-11所示。
3.4 拓展知识
Java的反射机制是Java特性之一，反射机制是构建框架技术 的基础所在。 在设计模式学习当中，学习抽象工厂的时候就用到了反射来 更加方便的读取数据库链接字符串等。Java中的配置文件 为.properties，称作属性文件。通过反射读取里边的内容。 这样代码是固定的，但是配置文件的内容我们可以改，这样 使我们的代码灵活了很多！ 典型的除了Hibernate之外，还有Spring也用到很多反射机制。 灵活掌握Java反射机制，对大家以后学习框架技术有很大的 帮助
3.2.4 使用反射机制的步骤
导入ng.relfect 包需 遵循以下3三个步骤： 第一步是获得你想操作的类 的 ng.Class 对象； 第二步是调用诸如 getDeclaredMethods 的方 法； 第三步使用 反射API 来操作这些信息。
3.2.5 反射机制的应用场景