Java知识点二十五：反射、类加载机制、Class类、反射创建对象

2、反射

2.1 引出反射

需求：

根据配置文件 re.properties指定信息,创建Cat对象并调用方法hi

方便之处：

可以更改配置文件的方法名称，更改源码中所调用的方法（不需要修改源码）

#re.properties内容：
classfullpath=chapter23.Cat
method=hi

package chapter23;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @Author 孑然
 */
public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        //根据配置文件 re.properties 指定信息， 创建对象并调用其方法

        //传统的方式 new对象 -> 调用方法
        //Cat cat = new Cat();
        //cat.hi();

        //尝试   明白反射
        Properties properties = new Properties();
        properties.load(new FileInputStream("test_pro_01/src/chapter23/re.properties"));

        String classfullpath = properties.get("classfullpath").toString();
        String method = properties.get("method").toString();
        System.out.println("classfullpath=" + classfullpath);//classfullpath=chapter23.Cat
        System.out.println("method=" + method);//method=hi


        //使用反射，创建对象
        //1.加载类
        Class aClass = Class.forName(classfullpath);
        //2.通过 aClass 得到你加载的类 chapter23.Cat 的实例
        Object o = aClass.newInstance();
        //3.通过 aClass 得到你加载的类 chapter23.Cat 的方法对象
        Method method1 = aClass.getMethod(method);
        //4.通过方法对象 method1 来实现调用方法
        method1.invoke(o);//传统方法 对象.方法()， 反射机制 方法.invoke(对象)

    }
}

2.2 反射机制

Java Reflection

1. 反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量，构造器,成员方法等等)，并能操作对象的属性及方法。
2. 反射在设计模式和框架底层都会用到
3. 加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象包含了类的完整结构信息。
4. 通过这个对象得到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构，所以,形象的称之为:反射

person 对象 --> 类型：Person类

aClass 对象 --> 类型：Class类

public final class Class<T> implements java.io.Serializable...

2.3 反射相关类

Java反射机制可以完成

1. 在运行时判断任意一个对象所属的类

2. 在运行时构造任意一个类的对象

3. 在运行时得到任意一个类所具有的成员变量和方法

4. 在运行时调用任意一个对象的成员变量和方法

5. 生成动态代理

反射相关的主要类：java.lang.reflection包下

1. java.lang.Class：代表一个类，Class对象表示某个类加载后在堆中的对象
2. java.lang.reflect.Method：代表类的方法, Method对象表示某个类的方法
3. java.lang.reflect.Field：代表类的成员变量
4. java.lang.reflect.Constructor：代表类的构造方法

//使用反射，创建对象
        //1.加载类
        Class aClass = Class.forName(classfullpath);
        Object o = aClass.newInstance();

        //获得方法对象
        Method method1 = aClass.getMethod(method);
        method1.invoke(o);//传统方法 对象.方法()， 反射机制 方法.invoke(对象)

        //获得属性对象
        Field nameField = aClass.getField("age");
        //getField 不能获得私有的属性
        System.out.println(nameField.get(o));

        //获得构造器对象, 可以指定构造器参数类型， 不执行，则返回无参构造器
        //使用反射，该类必须有无参构造
        Constructor constructor = aClass.getConstructor();
        System.out.println(constructor);
        Constructor constructor1 = aClass.getConstructor(String.class);//String.class就是String类的class对象
        System.out.println(constructor1);

2.4 反射优缺点

1. 优点：可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
2. 缺点：使用反射基本是解释执行,对执行速度有影响.

2.5 反射调用优化

反射调用优化——关闭访问检查

1. Method和Field、Constructor对象都有setAccessible()方法
2. setAccessible作用是启动和禁用访问安全检查的开关
3. 参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。
4. 参数值为false则表示反射的对象执行访问检查

2.6 Class类

1. Class也是类，因此也继承Object类【类图】
2. Class类对象不是new出来的，而是系统创建的【源码】
3. 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
4. 每个类的实例都会记得自己右哪个Class 实例 所生成
5. 通过Class可以完整得到一个类的完整结构，通过一系列API
6. Class对象是存在堆中的
7. 类的字节码二进制数据，是存在方法区的，有些地方称为类的元数据（包括方法代码、变量名、方法名、访问权限等）

常用方法：

1. static Class forName(String name)返回指定类名name的Class 对象
2. **Object newlnstance(）**调用缺省构造函数，返回该Class对象的一个实例
3. getName() 返回此Class对象所表示的实体(类、接口、数组类、基本类型等)名称
4. Class getSuperClass()返回当前Class对象的父类的Class对象
5. Class [] getlnterfaces()获取当前Class对象的接口
6. ClassLoader getClassLoader0返回该类的类加载器
7. Class getSuperclass(0返回表示此Class所表示的实体的超类的Class
8. Constructor[] **getConstructors()**返回一个包含某些Constructor对象的数组
9. Field[] **getDeclaredFields()**返回Field对象的一个数组
10. Method **getMethod(String name,Class … paramTypes)**返回一个Method对象，此对象的形参类型为paramType

2.7 获取Class对象的方式

三个阶段：

1. 编译期间：通过Class.foName（）
2. 加载阶段：通过 类名.class
3. 运行阶段：对象实例.getClass()

第四种：通过类加载器

---

Class.forName()：

前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法Class.forName(“全类名”)获取

应用场景：多用于配置文件，读取类全路径，加载类

---

类名.class

前提：若已知具体的类，通过类的class获取,该方式最为安全可靠,程序性能最高实例:Class cls2 = Cat.class;

应用场景： **多用于参数传递,**比如通过反射得到对应构造器对象.

---

对象.getClass()

前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例:Class clazz =对象.getClass0);

应用场景：通过创建好的对象，获取Class对象

---

类加载器获得

---

基本数据类型

Class cls = int.class

包装类型可以通过 TYPE属性获得

Class cls =  包装类.TYPE

2.8 类加载

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载

1. 静态加载：编译时就会加载相关的类，如果没有则报错，依赖性太强
2. 动态加载：运行时加载相关的类，如果不运行到该段代码，则不加载，不会报错。降低了依赖性

举例说明：

如果没有导入Person类的包， new Person在编译期间就会报错，而Class.forName（“Person”）只有在运行到这段代码时候，才会报错

switch(key) {
            case "1" :
                Dog dog = new Dog();//静态加载,依赖性很强dog.cry();
                break;
            case "2":
                //反射->动态加载
                Class cls = Class.forName( "Person");//加载Person类[动态加载]
                Object o = cls.newInstance(;
                Method m = cls.getMethod( "hi");
                m.invoke(o);
                System.out.println( "ok ");break;
            default:
                System.out.println( "do nothing.. ");
        }

2.9 类加载时机

1. 当创建对象时（new）//静态加载
2. 当子类被加载时，父类也被加载 //静态加载
3. 调用类中的静态成员时 //静态加载
4. 通过反射 //动态加载

2.10 类加载的五个阶段

1. 加载阶段

   JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的
   java.lang.Class对象

2. 连接阶段——验证

   1. 目的是为了确保Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
   2. 包括:文件格式验证(是否以魔数oxcafebabe开头)、元数据验证、字节码验证和符号引用验证[举例说明]
   3. 可以考虑使用-Xverify:none 参数来关闭大部分的类验证措施,缩短虚拟机类加载的时间。

3. 连接阶段——准备

   1. JVM 会在该阶段对静态变量，分配内存并初始化(对应数据类型的默认初始值，如0、OL、null、false等)。这些变量所使用的内存都将在方法区中进行分配

4. 连接阶段——解析

   1. 虚拟机将常量池内的符号引用替换为直接饮用的过程

5. 初始化 Initialization

   1. 到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行< clinit >0方法的过程。
   2. < clinit >(方法是由编译器按语句在源文件中出现的顺序，依次自动收集学的所有静态变量的赋值动作和静态代码块中的语句,并进行合并。
   3. 虚拟机会保证一个类的< clinit>（)方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit>（）方法，其他线程都需要阻塞等待，直到活动线程执行< clinit>0方法完毕

2.11 反射创建对象

1. 方式一：调用类中的public修饰的无参构造器【普通方式】

2. 方式二：调用类中的指定构造器【普通方式】

3. Class类相关方法【通过反射】

   • newlnstance ：调用类中的无参构造器,获取对应类的对象
   • getConstructor(Class…clazz)：根据参数列表，获取对应的public构造器对象
   • getDecalaredConstructor(Class.clazz)：根据参数列表,获取对应的所有构造器对象

4. Constructor类相关方法：【通过反射】

   • setAccessible：暴破【暴力破解】 //使其通过反射可以访问private构造器/方法/属性
   • newlnstance(Object…obj)：调用构造器

		//获取User类的Class对象
        Class<?> userClass = Class.forName("chapter23.User");

        //1.通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);

        //2.通过public的有参构造器创建实例
        Constructor<?> constructor = userClass.getConstructor(String.class);
        Object o1 = constructor.newInstance("李四");
        System.out.println(o1);

        //3.通过私有的有参构造器创建实例，该方法可以获得所有的构造器
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
        //暴力破解
        constructor1.setAccessible(true);
        constructor1.newInstance(25,"王二");

2.12 反射访问类中的成员

注意：

若属性为私有（private）属性，则需要setAccessible（true）方法爆破

若为静态属性，设置或访问属性值时，对象实例可置为null

		//访问属性
        //1.根据属性名获得Filed对象  私有属性需要爆破
        Field f = userClass.getDeclaredField("name");
        //2.爆破
        f.setAccessible(true);
        //3.访问
        f.set(o,"张三丰");//设置值，o为对象实例
        System.out.println(f.get(o));//获取属性值
        //3.1若是静态属性
        //f.set(null,"张三丰");
        //System.out.println(f.get(null));

2.13 反射访问类中的方法

访问方法

1. 根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名，XX.class);//得到本类的所有方法·
2. 获取对象：Object o=clazz.newlnstance0
3. 暴破：m.setAccessible(true);
4. 访问：Object returnValue = m.invoke(o,实参列表);
5. 注意：如果是静态方法，则invoke的参数o，可以写成null!

2.14 练习

package chapter23;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @Author 孑然
 */
@SuppressWarnings("all")
public class HomeWork02 {
    public static void main(String[] args) throws Exception {

        Class fileClass = Class.forName("java.io.File");
        //Object fileObj = fileClass.newInstance();

        //打印所有的构造器
        Constructor[] declaredConstructors = fileClass.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        Constructor constructor = fileClass.getConstructor(String.class);
        Object o = constructor.newInstance("e:\\mynew.txt");

        Method createNewFile = fileClass.getMethod("createNewFile");
        Object invoke = createNewFile.invoke(o);
    }
}