尚硅谷_陈鑫_第14章_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反射机制
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语⾔具备“动态性”：在运⾏时获取任意⼀个对象所属的类的相关信息;在运⾏时构造任意⼀个类的对象；在运⾏时获取任意⼀个类所具有的成员变量和⽅法；在运⾏时调⽤任意⼀个对象的⽅法。
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 反射机制是在运⾏状态中，对于任意⼀个类，都能够获得这个类的所有属性和⽅法，对于任意⼀个对象都能够调⽤它的任意⼀个属性和⽅法。
这种在运⾏时动态的获取信息以及动态调⽤对象的⽅法的功能称为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学习笔记反射机制
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反射机制
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反射机制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中的反射机制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中，每一个类都有反射对象，反射对象可以通过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对象。
java的反射机制
JAVA反射机制JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
1. 得到某个对象的属性public Object getProperty(Object owner, String fieldName) throws Exception {Class ownerClass = owner.getClass();Field field = ownerClass.getField(fieldName);Object property = field.get(owner);return property;Class ownerClass = owner.getClass()：得到该对象的Class。
Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。
Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
2. 得到某个类的静态属性public Object getStaticProperty(String className, String fieldName)throws Exception {Class ownerClass = Class.forName(className);Field field = ownerClass.getField(fieldName);Object property = field.get(ownerClass);return property;}Class ownerClass = Class.forName(className) ：首先得到这个类的Class。
JAVA反射机制定义-14页精选文档
JAVA反射机制定义：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
有时候我们说某个语言具有很强的动态性，有时候我们会区分动态和静态的不同技术与作法。
我们朗朗上口动态绑定（dynamic binding）、动态链接（dynamic linking）、动态加载（dynamic loading）等。
然而“动态”一词其实没有绝对而普遍适用的严格定义，有时候甚至像对象导向当初被导入编程领域一样，一人一把号，各吹各的调。
一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。
从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。
尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制：Reflection。
这个字的意思是“反射、映象、倒影”，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。
换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods1。
这种“看透class”的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。
Reflection和introspection是常被并提的两个术语。
JAVA反射.
JAVA反射机制Reflection是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。
例如，使用它能获得Java 类中各成员的名称并显示出来。
Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。
例如，Pascal、C 或者C++ 中就没有办法在程序中获得函数定义相关的信息。
JavaBean 是reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。
这些工具通过reflection 动态的载入并取得Java 组件(类) 的属性。
1. 一个简单的例子考虑下面这个简单的例子，让我们看看reflection 是如何工作的。
1.import ng.reflect.*;2.3.public class DumpMethods {4.public static void main(String args[]) {5.try {6. Class c = Class.forName("java.util.Stack");7.8. Method m[] = c.getDeclaredMethods();9.10.for (int i = 0; i < m.length; i++)11. System.out.println(m[i].toString());12. }13.catch (Throwable e){14. System.err.println(e);15. }16. }17.}它的结果输出为：1.public synchronized ng.Object java.util.Stack.pop()2.public ng.Object java.util.Stack.push(ng.Object)3.public boolean java.util.Stack.empty()4.public synchronized ng.Object java.util.Stack.peek()5.public synchronized int java.util.Stack.search(ng.Object)这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。
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反射机制问题：在运行时，对一个JA V A类，能否知道属性和方法；能否调用它的任意方法？答案是可以的，JA V A提供一种反射机制可以实现。
目录1什么是JA V A的反射机制2JDK中提供的Reflection API3JA V A反射机制提供了什么功能o获取类的Class对象o获取类的Fieldso获取类的Methodo获取类的Constructoro新建类的实例Class<T>的函数newInstance通过Constructor对象的方法newInstance4调用类的函数调用private函数5设置/获取类的属性值private属性6动态创建代理类动态代理源码分析7JA V A反射Class<T>类型源代码分析8JA V A反射原理分析Class文件结构JVM加载类对象，对反射的支持9JA V A反射的应用一、什么是JAV A的反射机制Java反射是Java被视为动态（或准动态）语言的一个关键性质。
这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields 和methods的所有信息，并可于运行时改变fields内容或唤起methods。
Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。
换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。
二、JDK中提供的Reflection APIJava反射相关的API在包ng.reflect中，JDK 1.6.0的reflect包如下图：Member接口该接口可以获取有关类成员（域或者方法）后者构造函数的信息。
AccessibleOb ject类该类是域(field)对象、方法(method)对象、构造函数(constructor)对象的基础类。
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)。
4.全部的方法
public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法 public Method[] getMethods() 返回此Class对象所表示的类或接口的public的方法
der();
• //5.测试JDK提供的Object类由哪个类加载器加载
• classloቤተ መጻሕፍቲ ባይዱder =
• Class.forName("ng.Object").getClassLoader();
• System.out.println(classloader); • //*6.关于类加载器的一个主要方法：
使用反射可以取得： 1.实现的全部接口 public Class<?>[] getInterfaces() 确定此对象所表示的类或接口实现的接口。
2.所继承的父类 public Class<? Super T> getSuperclass() 返回表示此 Class 所表示的实体（类、接口、基本 类型）的父类的 Class。
取Class对象 实例：Class clazz = “”.getClass(); 3）前提：已知一个类的全类名，且该类在类路径下，可通过 Class类的静态方法forName()获取，可能抛出
ClassNotFoundException
实例：Class clazz = Class.forName(“ng.String”); 4）其他方式(不做要求)
在运行时构造任意一个类的对象 在运行时判断任意一个类所具有的成员变量和方法 在运行时调用任意一个对象的成员变量和方法 生成动态代理
Java反射机制研究及应用
反射相关的主要API：
ng.Class:代表一个类 ng.reflect.Method:代表类的方法 ng.reflect.Field:代表类的成员变量 ng.reflect.Constructor:代表类的构造方法 … …
正常方式： 引入需要的”包类”名称
通过new实例化
取得实例化对象
反射方式： 实例化对象
getClass()方 法
得到完整的“包类”名称
Class 类
对象照镜子后可以得到的信息：某个类的属性、方法和构造 器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为 其保留一个不变的 Class 类型的对象。一个 Class 对象包含了 特定某个类的有关信息。 Class本身也是一个类 Class 对象只能由系统建立对象 一个类在 JVM 中只会有一个Class实例 一个Class对象对应的是一个加载到JVM中的一个.class文件 每个类的实例都会记得自己是由哪个 Class 实例所生成 通过Class可以完整地得到一个类中的完整结构
返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()
返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()
返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes)
14-2 理解Class类并 获取Class的实例
Class 类
在Object类中定义了以下的方法，此方法将被所有子类继承： ● public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射 的源头，实际上所谓反射从程序的运行结果来看也很好理解， 即：可以通过对象反射求出类的名称。
Bootstap Classloader Extension Classloader
引导类加载器：用C++编写的，是 JVM自带的类装载器，负责Java平台 核心库，用来装载核心类库。该加载 器无法直接获取
扩展类加载器：负责jre/lib/ext目录下 的jar包或 –D java.ext.dirs 指定目录下 的jar包装入工作库
• System.out.println(in);
14-4 创建运行时类的对象
创建运行时类的对象
有了Class对象，能做什么？
2.1.创建类的对象：调用Class对象的newInstance()方法
要 求：1）类必须有一个无参数的构造器。 2）类的构造器的访问权限需要足够。
难道没有无参的构造器就不能创建对象了吗？ 不是！只要在操作的时候明确的调用类中的构造器，并将参数传递进去之 后，才可以实例化操作。步骤如下： 1）通过Class类的getDeclaredConstructor(Class … parameterTypes) 取得本类的指定形参类型的构造器 2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的 各个参数。 3）通过Constructor实例化对象。
getResourceAsStream(String str):获取类路径下的指定文 件的输入流
• InputStream in = null;
• in = this.getClass().getClassLoader().getResourceAsStrea m("exer2\\test.properties");
Java反射机制
讲师：陈鑫
课程内容
14.1 Java反射机制概述 14.2 理解Class类并获取Class类的实例 14.3 类的加载与ClassLoader的理解 14.4 通过反射创建运行时类的对象 14.5 通过反射获取运行时类的完整结构 14.6 通过反射调用运行时类的指定属性、指定方法等 14.7 反射的应用：动态代理
注：test4.Person是test4包下的Person类
实例化Class类对象(四种方法)
1）前提：若已知具体的类，通过类的class属性获取，该方法 最为安全可靠，程序性能最高
实例：Class clazz = String.class; 2）前提：已知某个类的实例，调用该实例的getClass()方法获
自底向上检查类是否已装载 自顶向下尝试加载类
System Classloader
Custom Classloader
系统类加载器：负责java –classpath 或 –D java.class.path所指的目录下的 类与jar包装入工作 ，是最常用的加载 器
• //1.获取一个系统类加载器 • ClassLoader classloader =
3.全部的构造器
public Constructor<T>[] getConstructors() 返回此 Class 对象所表示的类的所有public构造方法。 public Constructor<T>[] getDeclaredConstructors() 返回此 Class 对象表示的类声明的所有构造方法。
类的装载
类的连接
类的初始化
将类的class文件读 入内存，并为之创 建一个 ng.Class对象。 此过程由类加载器 完成
将类的二进制数据 合并到JRE中
JVM负责对类 进行初始化
了解：ClassLoader
类加载器是用来把类(class)装载进内存的。JVM 规范定义了 两种类型的类加载器：启动类加载器(bootstrap)和用户自定 义加载器(user-defined class loader)。 JVM在运行时会产生 3个类加载器组成的初始化加载器层次结构 ，如下图所示：
14-1 Java反射机制概述
Java Reflection
Reflection（反射）是被视为动态语言的关键，反射机 制允许程序在执行期借助于Reflection API取得任何类的 内部信息，并能直接操作任意对象的内部属性及方法。
Java反射机制提供的功能 在运行时判断任意一个对象所属的类
返回一个Method对象，此对象的形参类型为paramType
反射的应用举例
• String str = "test4.Person"; • Class clazz = Class.forName(str); • Object obj = clazz.newInstance(); • Field field = clazz.getField("name"); • field.set(obj, "Peter"); • Object obj2 = field.get(obj); • System.out.println(obj2);
返回此Class对象所表示的实体（类、接口、数组类、基 本类型或void）名称
返回当前Class对象的父类的Class对象
Class [] getInterfaces()
获取当前Class对象的接口
ClassLoader getClassLoader()
返回该类的类加载器
Class getSuperclass()
ClassLoader.getSystemClassLoader(); • System.out.println(classloader); • //2.获取系统类加载器的父类加载器，即扩展类加载器 • classloader = classloader.getParent(); • System.out.println(classloader); • //3.获取扩展类加载器的父类加载器，即引导类加载器 • classloader = classloader.getParent(); • System.out.println(classloader); • //4.测试当前类由哪个类加载器进行加载 • classloader = • Class.forName("exer2.ClassloaderDemo").getClassLoa