类加载器-反射-模块

一、类加载器

1.类加载

类的加载：

就是将class文件读入内存，并为之创建一个java.lang.Class对象

任何类被使用时，系统都会为之创建一个java.lang.Class对象

类的连接：

验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致

准备阶段：负责为类的类变量分配内存，并设置默认初始化值

解析阶段：将类的二进制数据中的符号引用替换为直接引用

类的初始化：

在该阶段，主要就是对类变量进行初始化

类的初始化步骤：

假如类还未被加载和连接，则程序先加载和连接该类

假如该类的直接父类还未被初始化，则先初始化其直接父类

假如类中有初始化语句，则系统依次执行这些初始化语句

类的初始化时机：

创建类的实例

调用类的类方法

访问类或者接口的类变量，或者为该类赋值

使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

初始化某个类的子类

直接使用java.exe命令来运行某个主类

2.类加载器

JVM的类加载机制：
全盘负责：就是当一个类加载器负责加载某个Class时，该类所依赖的和引用的其他类也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入

父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该类，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类

缓存机制：保证所有加载过的类都会被缓存，当程序需要使用某个类对象时，类加载器先从缓存区中搜索该类，只有当缓存区中不存在该类对象时，系统才会读取该类对应的二进制数据，并将其转换成类对象，存储到缓存区

ClassLoader:是负责加载类的对象

java运行时具有以下内置加载器：

Bootstrap classloader:虚拟机的内置加载器，通常表示为null，并且没有父null

Platform class loader:平台类加载器可以看到所有平台类，平台类包括由平台类加载器或者其祖先定义的Java SE平台API，其实现类和JDK特定的运行时类

System class loader:程序加载类。系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类

public class HelloWorld {
    public static void main(String[] args) {
        //static ClassLoader getSystemClassLoaser():返回用于委派的系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1

        //ClassLoader getParent():返回父类加载器进行委派
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);//jdk.internal.loader.ClassLoaders$PlatformClassLoader@7ef20235

        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//null
    }
}

二、反射

1.概述

Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。

2.获取Class类的对象

public class HelloWorld {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//        获取Class类
        Class<?> c = Class.forName("Student");

        //Constructor<?>[] getConstructors()返回一个包含Constructor对象的数组，Constructor对象反应了由该Class对象表示的类的所有公共构造函数
        //Constructor<?>[] cons = c.getConstructors();
//        public Student(java.lang.String,int,java.lang.String)
//        public Student()
        //Constructor<?> getDeclaredConstructors()返回反应由该Class对象表示的类声明的所有构造函数的Constructor对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
//        public Student(java.lang.String,int,java.lang.String)
//        Student(java.lang.String,int)
//        private Student(java.lang.String)
//        public Student()
        for (Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("-------------------");
        //Constructor<T> getConstructor()返回一个Constructor对象,该对象反应了由该Class对象表示的类的一个公共构造函数
        //Constructor<T> getDeclaredConstructor()返回一个Constructor对象,该对象反应了由该Class对象表示的类的一个指定构造函数
        Constructor<?> con = c.getConstructor();
        //Constructor提供了一个类的单个构造函数的信息和访问权限
        //T newTnstance使用由此Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数
        Object obj = con.newInstance();
        System.out.println(obj);
    }
}

练习1

        Class<?> c = Class.forName("Student");
        Constructor<?> con = c.getConstructor(String.class, int.class, String.class);
        Object obj = con.newInstance("林青霞", 30, "西安");
        System.out.println(obj);

练习2

        Class<?> c = Class.forName("Student");
        Constructor<?> con = c.getDeclaredConstructor(String.class);
        //暴力反射
        //public void setAccessible(boolean flag)；值为true，取消访问检查
        con.setAccessible(true);
        Object obj = con.newInstance("林青霞");
        System.out.println(obj);

3.反射获取成员变量并使用

public class HelloWorld {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<?> c = Class.forName("Student");

        //Field[] getFields()返回一个包含Field对象的数组，Field对象反映由该类对象表示的类或接口的所有可访问的公共字段
        //Field[] getDeclaredFields()返回一个包含Field对象的数组，反映了由该类对象表示的类或接口声明的所有字段
//        Field[] fields = c.getFields();//public String address;
        Field[] fields = c.getDeclaredFields();//private String name,int age,public String address;
        for (Field field:fields){
            System.out.println(field);
        }

        //Field getField(String name)返回一个Field对象，对象反映由该类对象表示的类或接口的指定的公成员共字段
        //Field getDeclaredField(String name)返回一个Field对象，对象反映由该类对象表示的类或接口的指定声明字段
        Field addressField = c.getField("address");

        //获取无参构造方法获取对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        addressField.set(obj,"西安");//给obj的成员变量addressField赋值西安

        System.out.println(obj);

    }
}

练习

        Class<?> c = Class.forName("Student");
        Field name = c.getDeclaredField("name");
        Field age = c.getDeclaredField("age");
        Field address = c.getDeclaredField("address");
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        name.setAccessible(true);
        name.set(obj,"林青霞");
        age.setAccessible(true);
        age.set(obj,30);
        address.set(obj,"西安");
        System.out.println(obj);

4.反射获取成员方法并使用

public class HelloWorld {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<?> c = Class.forName("Student");

        //方法[] getMethods()返回一个包含方法对象的数组，方法对象反映由该类对象表示的类或接口的所有公共方法，包括由类或接口声明的对象以及从超类和超级接口继承的类
        //方法[] getDeclaredMethods()
//        Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for (Method method:methods){
            System.out.println(method);
        }

        Method m = c.getMethod("method1");

        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        m.invoke(obj);
    }
}

练习

        Class<?> c = Class.forName("Student");

        Constructor<?> con = c.getDeclaredConstructor();
        Object obj = con.newInstance();

        Method method1 = c.getMethod("method1");
        method1.invoke(obj);

        Method method2 = c.getMethod("method2", String.class);
        method2.invoke(obj,"林青霞");

        Method method3 = c.getMethod("method3", String.class, int.class);
        Object obj1 = method3.invoke(obj,"林青霞", 30);
        System.out.println(obj1);

        Method function = c.getDeclaredMethod("function");
        function.setAccessible(true);
        function.invoke(obj);

5.反射练习之越过反省检查

ArrayList<Integer> array=new ArrayList<>();

        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add", Object.class);
        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");

        System.out.println(array);

6.反射练习之运行配置文件指定内容

public class HelloWorld {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException, IOException {
        //加载数据
        Properties prop=new Properties();
        FileReader fr=new FileReader("D:\\522\\java.text");
        prop.load(fr);
        fr.close();

        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //通过反射来使用
        Class<?> c = Class.forName(className);
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getMethod(methodName);
        m.invoke(obj);
    }
}

三、模块化

模块的基本使用步骤：

·创建2个模块:myOne，myTwo

·在模块的src目录下新建一个名为module-info.java的描述性文件，该文件专门定义模块名，访问权限，模块依赖等信息，描述性文件中使用模块导出和模块依赖来进行配置和使用

·模块中所有未导出的包都是模块私有的，他们是不能在模块之外被访问的，在myOne这个模块下的描述性文件中配置模块导出：exports 包名；

·一个模块要访问其他模块，必须明确指定依赖哪些模块，未明确指定依赖的模块不能访问，在myTwo这个模块下的描述性文件中配置模块依赖：requires 模块名；