下载文档原格式
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反射机制一、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语⾔的⼀个重要特性，使得Java语⾔具备“动态性”：在运⾏时获取任意⼀个对象所属的类的相关信息;在运⾏时构造任意⼀个类的对象；在运⾏时获取任意⼀个类所具有的成员变量和⽅法；在运⾏时调⽤任意⼀个对象的⽅法。
JAVA反射机制是构建框架技术的基础。
例如后续学习的Spring框架等，都使⽤到反射技术；Java的反射机制依靠反射API实现，反射API主要包括以下⼏个类，后续学习：ng.Class类：代表⼀个类;ng.reflect.Field 类：类的成员变量（成员变量也称为类的属性）;ng.reflect.Method类：类的⽅法;ng.reflect.Constructor 类：类的构造⽅法;ng.reflect.Array类：动态创建数组，以及访问数组的元素的静态⽅法。
通过Class实例化对象_class.newInstance()import ng.reflect.Constructor;import ng.reflect.InvocationTargetException;public class T31反射创建对象 {public static void main(String[] args) throws ClassNotFoundException, InstantiationException,IllegalAccessException, NoSuchMethodException, SecurityException,IllegalArgumentException, InvocationTargetException {Class<?> _class = Class.forName("ng.String");// 1.直接创建对象Object newInstance = _class.newInstance();// 说明创建了⼀个空字符串:""System.out.println(newInstance.equals(""));// 2.通过获取构造⽅法,构造对象Constructor<?> _constr = _class.getConstructor(_class);Object _obj = _constr.newInstance("实例化对象");System.out.println(_obj);}}true实例化对象私有成员也能获取包括：构造,变量,⽅法getDeclaredXXX可以获取私有成员package ahjava.p07reflect;import ng.reflect.Constructor;import ng.reflect.Field;import ng.reflect.Method;public class T32获取私有成员⼀览 {public static void main(String[] args) throws Exception {// get构造⽅法();// getMethod();getField();}static void get构造⽅法() {Class<Dog> _class = Dog.class;Constructor[] _ctors = null;System.out.println("---↓↓↓getConstructors()获取public构造⽅法");_ctors = _class.getConstructors();for (Constructor c : _ctors) {System.out.println(c);}System.out.println("---↓↓↓getDeclaredConstructors()获取全部构造⽅法");_ctors = _class.getDeclaredConstructors();for (Constructor c : _ctors) {System.out.println(c);}}static void getMethod() throws NoSuchMethodException, SecurityException {Class<Dog> _class = Dog.class;Method[] mtds;System.out.println("===↓↓↓.getMethods()所有public⽅法，包括继承来的⽅法=====");mtds = _class.getMethods();for (Method md : mtds) {System.out.println(md);}System.out.println("===↓↓↓.getDeclaredMethods()所有⾃⼰声明的⽅法=====");mtds = _class.getDeclaredMethods();for (Method md : mtds) {System.out.println(md);}System.out.println("=====获取指定⽅法=====");System.out.println("-----.getMethod()只能获取public⽅法");System.out.println("-----.getDeclaredMethod()可获取private⽅法");// (⽅法名,参数类型...)Method m = _class.getDeclaredMethod("_someMethod", String.class);System.out.println(m);}static void getField()throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Class<Dog> _class = Dog.class;Field[] fields;System.out.println("=====.getFields()=====");fields = _class.getFields();for (Field fd : fields) {System.out.println(fd);}System.out.println("=====.getDeclaredFields()=====");fields = _class.getDeclaredFields();for (Field fd : fields) {System.out.println(fd);}System.out.println("=====获取指定变量=====");System.out.println("-----.getDeclaredField(...)");Field f = _class.getDeclaredField("fPrivate");System.out.println(f);}}class Dog {private Dog() {System.out.println("private构造⽅法");}public Dog(String name) {System.out.println("public构造⽅法");}public Dog(String name, int n) {System.out.println("public构造⽅法");}// -----变量-----private String fPrivate = "private变量";protected String fProtected = "protected变量";public String fPublic = "public变量";String fDefault = "未修饰变量";// -----⽅法-----private void _mPrivate() {}protected void _mProtected() {}public void _mPublic() {}void _mDefault() {}// ---private void _someMethod(String s) {}}=====.getFields()=====public ng.String ahjava.p07reflect.Dog.fPublic=====.getDeclaredFields()=====private ng.String ahjava.p07reflect.Dog.fPrivateprotected ng.String ahjava.p07reflect.Dog.fProtectedpublic ng.String ahjava.p07reflect.Dog.fPublicng.String ahjava.p07reflect.Dog.fDefault=====获取指定变量=====-----.getDeclaredField(...)private ng.String ahjava.p07reflect.Dog.fPrivate获取私有成员应⽤：import ng.reflect.Constructor;import ng.reflect.Field;import ng.reflect.Method;public class T33获取私有成员应⽤ {public static void main(String[] args) throws Exception {Class<Dog2> _class = Dog2.class;// 获取(私有)构造⽅法Constructor<Dog2> _constr = _class.getDeclaredConstructor();_constr.setAccessible(true);Object _obj = _constr.newInstance();// 获取(私有)成员变量Field _field = _class.getDeclaredField("name");_field.setAccessible(true);System.out.println("原内容：" + _field.get(_obj));_field.set(_obj, "⼆狗");// 获取(私有)⽅法(⽅法名,参数类型列表)Method m = _class.getDeclaredMethod("show", String.class, int.class); m.setAccessible(true);// __invoke:调⽤对象obj的当前⽅法，args为⽅法参数；m.invoke(_obj, "狗", 2);}}class Dog2 {private Dog2() {System.out.println("私有构造⽅法");}private String name = "SS";private void show(String str1, int n2) {System.out.println(name + ":'汪汪'" + str1 + n2);}}私有构造⽅法原内容：SS⼆狗:'汪汪'狗2。
什么是Java的反射机制⼀、反射机制概述Java 反射机制是在运⾏状态中，对于任意⼀个类，都能够获得这个类的所有属性和⽅法，对于任意⼀个对象都能够调⽤它的任意⼀个属性和⽅法。
这种在运⾏时动态的获取信息以及动态调⽤对象的⽅法的功能称为Java 的反射机制。
Class 类与ng.reflect 类库⼀起对反射的概念进⾏了⽀持，该类库包含了Field,Method,Constructor类(每个类都实现了Member 接⼝)。
这些类型的对象时由JVM 在运⾏时创建的，⽤以表⽰未知类⾥对应的成员。
这样你就可以使⽤Constructor 创建新的对象，⽤get() 和set() ⽅法读取和修改与Field 对象关联的字段，⽤invoke() ⽅法调⽤与Method 对象关联的⽅法。
另外，还可以调⽤getFields() getMethods() 和 getConstructors() 等很便利的⽅法，以返回表⽰字段，⽅法，以及构造器的对象的数组。
这样匿名对象的信息就能在运⾏时被完全确定下来，⽽在编译时不需要知道任何事情。
⼆、获取字节码的⽅式在Java 中可以通过三种⽅法获取类的字节码(Class)对象通过Object 类中的getClass() ⽅法，想要⽤这种⽅法必须要明确具体的类并且创建该类的对象。
所有数据类型都具备⼀个静态的属性.class 来获取对应的Class 对象。
但是还是要明确到类，然后才能调⽤类中的静态成员。
只要通过给定类的字符串名称就可以获取该类的字节码对象，这样做扩展性更强。
通过Class.forName() ⽅法完成，必须要指定类的全限定名，由于前两种⽅法都是在知道该类的情况下获取该类的字节码对象，因此不会有异常，但是Class.forName() ⽅法如果写错类的路径会报 ClassNotFoundException 的异常。
ackage com.jas.reflect;public class ReflectTest {public static void main(String[] args) {Fruit fruit = new Fruit();Class<?> class1 = fruit.getClass(); //⽅法⼀Class<?> class2 = Fruit.class; //⽅法⼆Class class3 = null;try { //⽅法三，如果这⾥不指定类所在的包名会报 ClassNotFoundException 异常class3 = Class.forName("com.jas.reflect.Fruit");} catch (ClassNotFoundException e) {e.printStackTrace();}System.out.println(class1 + " " +class2 + " " + class3);}}class Fruit{}三、通过反射机制获取类信息通过反射机制创建对象，在创建对象之前要获得对象的构造函数对象，通过构造函数对象创建对应类的实例。
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反射机制1、反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，可自描述和自控制2、在Java中反射机制被称为Reflection，它允许运行中的Java程序对自身进行检查，并能直接操作程序的内部属性或方法。
Reflection机制允许程序在正在执行的过程中，利用Reflection APIs取得任何已知名称的类的内部信息，包括：package、type parameters、superclass、implemented interfaces、inner classes、outer classes、fields、constructors、methods、modifiers等，并可以在执行的过程中，动态生成Instances、变更fields内容或唤起methods。
3、反射机制中需要使用到的类：4、Class类是整个Java反射机制的源头，Class类本身表示Java对象的类型，我们可通过一个Object对象的getClass()方法取得一个对象的类型，此函数返回的就是一个Class类。
获取Class对象的方法有很多种：代码示例：Class类.txt5、Class类提供了四个public方法，用于获取某个类的构造方法：a)Constructor getConstructor(Class[] params) 根据构造函数的参数，返回一个具体的具有public属性的构造函数；b)Constructor getConstructors() 返回所有具有public属性的构造函数数组c)Constructor getDeclaredConstructor(Class[] params) 根据构造函数的参数，返回一个具体的构造函数（不分public和非public属性）d)Constructor getDeclaredConstructors() 返回该类中所有的构造函数数组（不分public和非public属性）代码示例：获取反射类中的构造方法.txt6、与获取构造方法的方式相同，存在四种获取成员方法的方式：a)Method getMethod(String name, Class[] params) 根据方法名和参数，返回一个具体的具有public属性的方法b)Method[] getMethods() 返回所有具有public属性的方法数组c)Method getDeclaredMethod(String name, Class[] params) 根据方法名和参数，返回一个具体的方法（不分public和非public属性）d)Method[] getDeclaredMethods() 返回该类中的所有的方法数组（不分public和非public属性）代码示例：获取反射类的方法.txt7、四种获取成员属性的方法：a)Field getField(String name) 根据变量名，返回一个具体的具有public属性的成员变量b)Field[] getFields() 返回具有public属性的成员变量的数组c)Field getDeclaredField(String name) 根据变量名，返回一个成员变量（不分public和非public属性）d)Field[] getDelcaredField() 返回所有成员变量组成的数组（不分public和非public属性）代码示例：获取反射类中的属性和属性值.txt8、在得到一个类的Class对象之后，可以利用类Constructor去实例化该对象。
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的反射机制是指在程序运行时，可以动态地获取一个类的信息，并且可以通过反射在运行时动态地调用和操作类的方法、属性、构造方法等。
反射机制使得Java具备了一定的动态性，可以在运行时动态地加载、创建和操作对象，开发出更加灵活和通用的代码。
本文将详细介绍Java的反射机制，包括反射的基本概念、如何获取类的信息、如何调用类的方法、如何操作类的属性以及如何动态创建对象等。
1.反射的基本概念反射是Java语言的一种机制，它可以在运行时动态地获取和操作一个类的信息。
在Java中，每一个类都对应一个Class对象，该对象包含了类的所有信息，比如类的名称、字段、方法等。
通过反射，可以在程序运行时动态地获取并操作一个类的Field、Method、Constructor等。
2.获取类的信息在Java中，可以通过Class类的静态方法forName(来获取一个类的Class对象。
例如，要获取String类的Class对象，可以使用以下代码：Class<?> cls = Class.forName("ng.String");通过Class的静态方法forName(可以根据类的全限定名获取该类的Class对象，但是需要注意的是，要使用全限定名来获取Class对象。
如果需要获取数组类型的Class对象，则可以使用Class类的静态方法forName(，并在类名后加上"[]"表示。
3.调用类的方法通过反射机制，可以在运行时动态地调用一个类的方法。
首先，需要获取Method对象，然后使用Method对象的invoke(方法来调用方法。
下面是一个示例代码：Class<?> cls = Class.forName("ng.String");Object obj = cls.newInstance(; //创建类的实例Method method = cls.getMethod("length"); //获取方法对象Object result = method.invoke(obj); //调用方法int length = (int) result; //获取调用结果System.out.println(length); //输出结果4.操作类的属性通过反射机制，还可以在运行时动态地操作一个类的属性。
Java语言中的反射机制Java是一种优秀的编程语言，拥有着强大的功能和广泛的应用。
其中反射机制是Java语言的一个重要特性，它使得程序员可以在运行时借助Java程序来探索、分析和修改程序的内部结构。
本文将介绍Java反射机制的原理、用法和注意事项等方面内容。
一、什么是反射机制？反射机制是指Java程序在运行时能够动态地获取和检查一个类的属性、方法和构造函数等信息，并且可以在运行时修改这些元素的值或行为。
在Java中，每一个类都有反射对象，反射对象可以通过Java反射API来访问和操作。
Java反射API提供了一系列的类和方法，使得程序员能够在运行时动态地加载、访问、使用和操作Java类。
二、Java反射机制的应用Java反射机制可以用在很多方面。
例如，当代码需要在运行时动态地加载一个类时，就需要使用反射机制。
当需要实现动态代理时，反射机制也是必不可少的。
Java的注解机制也必须借助反射机制来实现。
下面我们将具体介绍Java反射机制的常见应用：1. 动态加载类和调用方法Java反射机制可以在运行时动态地创建一个类的实例、访问类的静态变量、调用成员方法等操作。
例如，可以使用Java反射机制创建一个类的对象，并在运行时调用类中的方法，如下所示：Class clazz = Class.forName("com.example.MyClass");Method method = clazz.getDeclaredMethod("myMethod");Object object = clazz.newInstance();method.invoke(object);上述代码中，首先通过Class.forName方法获取类com.example.MyClass的Class对象，然后使用getDeclaredMethod 方法获取myMethod方法的Method对象。
