目录
动态语言（比如JavaScript等）在运行时可以改变自身结构，增加新的函数或者对象。动态语言的在编写的时候不必指定变量的类型
静态语言（比如Java等）在运行时不能改变自身的结构，在编译期就要指定变量的类型。但是反射机制，让Java获得类似动态语言的特性，具有一定的动态性。
.java是源程序，是我们编写的代码，.class是编译后的程序，本质上是一个二进制文件。
类加载机制：
当程序需要用到某个类的时候，如果这个类还没有加载到内存中，那么Java虚拟机就会将这个类加载到内存中进行初始化。
具体初始化的步骤有：
- 加载：将.class文件读入内存（具体是在堆内存的方法区），并为之创建一个Class类型的对象
放一张廖雪峰老师网站的截图
廖雪峰老师网站的链接：
这个String类的Class实例就会保存这个String类的全部信息
注意：
创建String类的语句是public final class String，而创建Class类的语句是public final class Class。这里的String是类名，Class也是类名。而String类的对象叫String类型对象，Class类的对象叫Class类型对象。不同的是，Class类是未知的，它可以是任意的类。就比如拿到一个class文件，我们不知道这个class文件里面是什么样子，有哪些变量和方法。那么就可以通过Class类型对象，来反方向获得这个class文件的类的全部信息。这个过程就叫做反射。
- 连接：具体又分为验证，准备，解析三个步骤。
（1）验证：对文件格式等内部结构是否正确
（2）准备：为类变量分配内存并设置初始值
（3）解析：将类的二进制数据中的符号引用替换为直接引用 - 初始化：到这一步开始执行类里面自己编写的代码，完成类的初始化
类加载器：负责将.class文件加载到内存中，并为之生成对应的Class对象。
反射的定义
加载完类之后产生的这个Class类型的对象（一个类只会有一个Class对象），会包含这个类的完整信息（包括类名，父类，接口，这个类的所有方法，变量等），我们通过这个Class对象看到这个对象对应的类的所有信息。这个对象就可以比喻成一面镜子，透过这面镜子看到类的信息。
这种通过Class对象获得其对应的类的所有信息的行为称为反射。（这里又总结一遍反射的定义）
类似于public final class String，String类一样，String类有构造方法和成员方法。
public final class Class是反射的核心类，也同样有着一套自己的构造方法和成员方法
反射的功能（包括但不限于）：
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
举一个例子，比如说有一个class文件，但是不知道这个文件里面的详情。所以通过forName创建这个class文件的Class类型对象，再通过这个对象反过来获取class文件的内容，内容包括但不限于成员变量和方法等。下面有具体的实例代码来说明这个例子。
获取Class类型对象
既然获取了一个class类的Class对象，就可以获得这个类的全部信息，那么我们该如何获得这个Class对象呢？
- 通过Object中的getClass()方法获取，返回该Object的运行时类
- 通过类名获取静态属性class
- Class类中的静态方法 public static 类<?> forName(String className)（通常使用这个方法）
package test.reflexDemo;
public class Student {
private String name;
int age;
public String hobby;
public Student(){
}
private Student(String name){
this.name = name;
}
Student(String name,int age){
this.name = name;
this.age = age;
}
public Student(String name,int age,String hobby){
this.name = name;
this.age = age;
this.hobby = hobby;
}
public void test(){
System.out.println("public修饰的无参的方法");
}
public String show(String name,int age){
System.out.println("public修饰的含参的方法");
return name + "---" + age;
}
void function(String name){
System.out.println("默认修饰符的含参的方法，姓名是 "+name);
}
private void demo(String hobby){
System.out.println("private修饰的含参的方法，爱好是 "+hobby);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", hobby='" + hobby + '\'' +
'}';
}
}
这里的Student就相当于Class，这里的s就相当于Class类型对象
package test.reflexDemo;
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException {
//这里的Student就相当于Class，这里的s就相当于Class类型对象
Student s = new Student();
//方式一，getClass()方法,获得该对象的运行时类
Class<? extends Student> c1 = s.getClass();
Student s1 = new Student();
Class<? extends Student> c2 = s1.getClass();
System.out.println(c1==c2); // true
//这里结果为true的原因，同一个class可以new出来多个对象，但是只会对应一个Class类型对象
//所以c1和c2是一样的，但是s和s1是不一样的
System.out.println(s==s1); // false
System.out.println("-----------------------------");
//方式二，通过类名获得静态属性class
Class<Student> c3 = Student.class;
System.out.println(c3 == c1); //true
System.out.println(c3 == c2); //true
System.out.println("-----------------------------");
//方式三，利用Class类中的静态方法forName(String className)
//这个方法会返回给定字符串名称className的类或接口相关联的类对象，然后通过类对象调用类的方法和变量
//注意这里的className需要写类在项目中的具体位置
Class<?> c4 = Class.forName("test.reflexDemo.Student");
System.out.println(c4 == c3); //true
System.out.println(c4 == c2); //true
System.out.println(c4 == c1); //true
//Class后面的泛型可以不添加
//这样看起来更直接一些，c5是Class类型
Class c5 = Class.forName("test.reflexDemo.Student");
System.out.println(c5 == c4); //true
}
}
根据Class类型对象来创建类的实例
上面成功获得了Class类型对象，那么如何通过Class类型对象来创建对应的class类的对象呢？
思路是通过Class类型对象，来获得对应类的构造方法，然后再用构造方法来创建类的实例。
批量获取构造方法
package test.reflexDemo;
import java.lang.reflect.Constructor;
public class Demo2 {
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName("test.reflexDemo.Student");
//public Constructor<?>[] getConstructors()
// 返回文件中的所有public修饰的构造方法，不会获取private或者默认修饰的构造方法
Constructor[] constructors = c.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println("----------------------");
//public Constructor<?>[] getDeclaredConstructors()
//返回所有的构造方法，包括private和默认修饰的构造方法
//另外这里获取的private修饰的构造方法也可以构建对象
Constructor[] dcs = c.getDeclaredConstructors();
for (Constructor d : dcs) {
System.out.println(d);
}
}
}
获取单个的构造方法
package test.reflexDemo;
import java.lang.reflect.Constructor;
public class Demo3 {
public static void main(String[] args) throws Exception {
Class c = Class.forName("test.reflexDemo.Student");
//public Constructor<T> getConstructor(Class<?>... parameterTypes)
//括号里的参数是指具体数据类型对应的类，比如String要写成String.class
//什么都没写就是获取默认无参构造方法
Constructor cons1 = c.getConstructor();
System.out.println("无参构造方法"+cons1);
Constructor cons2 = c.getConstructor(String.class,int.class,String.class);
System.out.println("有参构造方法"+cons2);
//同样的，这样只能获得public类型,要想获得private类型需要改为
//getDeclaredConstructor
Constructor cons3 = c.getDeclaredConstructor(String.class);
System.out.println("private修饰的有参构造方法"+cons3);
System.out.println("--------------------------");
//根据获得的构造方法创建实例
//public T newInstance(Object... initargs)
//括号里面写要传入构造方法中的参数
Object o1 = cons1.newInstance();
System.out.println(o1);
//这里可以向下转型
Student s = (Student)o1;
System.out.println(s);
//虽然获得了Private修饰的构造方法，但不能直接写入，会报权限不足的异常
//需要强行获取权限，暴力访问
cons3.setAccessible(true);
Object o2 = cons3.newInstance("张");
System.out.println(o2);
}
}
结果为
总结一下过程：
- 获取Class类型的对象 Class c = Class.forName();
- 通过Class对象获取构造方法 (由Class对象来调用）
（1）public无参构造方法 Constructor cons = c.getConstructor();
（2）public有参构造方法 Constructor cons = c.getConstructor(String.class);
（3）private有参构造方法 Constructor cons = c.getDeclaredConstructor(String.class); - 通过构造方法来创建实例（由Constructor对象来调用）
（1）public无参构造方法 Object o = constructor.newInstance();
（2）public有参构造方法 Object o = constructor.newInstance(“张”);
（3）private有参构造方法 先constructor.setAccessible(true);获取权限，后constructor.newInstance(“张”);创建对象
获取成员变量
批量获得成员变量
package test.reflexDemo;
import java.lang.reflect.Field;
public class Demo4 {
public static void main(String[] args) throws Exception{
Class c = Class.forName("test.reflexDemo.Student");
//获取所有的成员变量
//getFields()返回一个Field类型的数组，包含所有public修饰的成员变量
Field[] fields = c.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("--------------------");
//getDeclaredFields()获取所有的成员变量，包括被private和默认修饰等类型修饰的变量
Field[] declaredFields = c.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
}
}
获取单个成员变量并修改变量的值
package test.reflexDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class Demo5 {
public static void main(String[] args) throws Exception{
Class c = Class.forName("test.reflexDemo.Student");
//getField(String name)根据变量名获取变量
Field hobby = c.getField("hobby");
System.out.println(hobby);
//set(Object obj, Object value)将指定obj对象的类的变量的值改为value
//这个方法由上面获取的Field变量对象来调用
Constructor constructor = c.getConstructor();
Object o = constructor.newInstance();
hobby.set(o,"敲代码");
System.out.println(o);
System.out.println("------------------------");
//如果要修改被private修饰的变量，同样需要强行修改权限
Field name = c.getDeclaredField("name");
name.setAccessible(true);
name.set(o,"姓名是张");
System.out.println(o);
}
}
结果是
总结一下修改成员变量的过程：
- 获取Class类型的对象 Class c = Class.forName();
- 通过Class对象获取变量 Field hobby = c.getField(“hobby”); （由Class对象调用）
括号里面写入变量名 - 通过Class对象获取构造方法 Constructor cons = c.getConstructor();（由Class对象调用）
- 通过构造方法创建对象 Object o = cons.newInstance();（由constructor对象调用）
- 通过Field变量来修改成员变量的值 hobby.set(o,“敲代码”); （由Field对象来调用）
括号里面的参数传入对象o 和 具体的变量值"敲代码"
获取成员方法
批量获取成员方法
package test.reflexDemo;
import java.lang.reflect.Method;
public class Demo6 {
public static void main(String[] args) throws Exception{
Class c = Class.forName("test.reflexDemo.Student");
//批量获取成员方法
//只能获取public修饰的方法
Method[] methods = c.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("-------------------");
//获取所有的成员方法，包括private修饰的方法
Method[] declaredMethods = c.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
}
}
getMethods()会把继承自父类的方法也包含进去，所以显得很多
getDeclaredMethods()只会包含类里面的自己的方法
获取单个成员方法，并调用
package test.reflexDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Demo7 {
public static void main(String[] args) throws Exception{
Class c = Class.forName("test.reflexDemo.Student");
//getMethod(String name,类<?>... parameterTypes)
//括号里面的参数写方法名和方法参数的class文件,比如String写成String.class
//test()是无参方法，所以这里只需要方法名
Method test = c.getMethod("test");
System.out.println(test);
//Object invoke(Object obj, Object... args)
//给定对象obj和方法参数，调用此方法
Constructor constructor = c.getConstructor();
Object o = constructor.newInstance();
test.invoke(o);
System.out.println("------------------");
//同理，如果要调用private修饰的方法，需要修改权限，强行访问
//这里需要用getDeclaredMethod，否则会报NoSuchMethodException异常
Method demo = c.getDeclaredMethod("demo", String.class);
demo.setAccessible(true);
demo.invoke(o,"看书");
}
}
结果为
总结一下调用成员方法的过程：
- 获取Class类型的对象 Class c = Class.forName();
- 通过Class对象获取方法 （由Class对象调用）
（1）无参方法 Method method = c.getMethod(“test”);
（2）有参方法 Method method = c.getMethod(“test”,String.class); - 通过Class对象获取构造方法 Constructor cons = c.getConstructor();（由Class对象调用）
- 通过构造方法来构建实例 Object o = cons.newInstance(); （由Constructor对象来调用）
- 通过获得的方法对象来调用invoke方法 （由Method对象来调用）
（1）无参方法 method.invoke(o);
（2）有参方法 method.invoke(o，参数值);
1093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
