Java学习笔记day25-类加载器及反射

最新推荐文章于 2022-02-27 00:38:25 发布

猫薄荷>3<

最新推荐文章于 2022-02-27 00:38:25 发布

阅读量321

点赞数

分类专栏：笔记文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/qq_41615150/article/details/123124476

版权

笔记专栏收录该内容

27 篇文章 2 订阅

订阅专栏

类加载器

类加载时机

创建类的实例(对象)
调用类的类方法（方法为静态方法）
访问类或者接口的类变量，或者为该类变量赋值(静态变量)
使用反射的方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

类加载的过程

加载

链接

初始化

类加载器的分类

启动类加载器(Bootstrap Classloader)：虚拟机内置的类加载器；
平台类加载器(Platform Classloader)：负责加载JDK中一些特殊的模块；
系统类加载器(System.Classloader)：负责加载用户类路径上所指定的类库。

双亲委派模型

public class ClassLoaderTest1 {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        //获取系统类加载器的父加载器，即平台类加载器
        ClassLoader parent1 = systemClassLoader.getParent();
        //获取平台类加载器的父加载器，即启动类加载器
        ClassLoader parent2 = parent1.getParent();
        System.out.println("系统类加载器"+systemClassLoader);
        System.out.println("平台类加载器"+parent1);
        System.out.println("启动类加载器"+parent2);
    }
}

类加载器常用方法

方法名	说明
public static ClassLoader getSystemClassLoader()	获取系统类加载器
public InputStream getResourceAsStream(String name)	加载某一个资源文件

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ClassLoaderTest2 {
    public static void main(String[] args) throws IOException {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        //利用加载器去加载一个指定的文件
        //参数：文件的路径
        //返回值：字节流
        InputStream is = systemClassLoader.getResourceAsStream("prop.properties");
        Properties prop = new Properties();
        prop.load(is);
        System.out.println(prop);
        is.close();
    }
}

反射

概述

Java反射机制

是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法（无视修饰符）；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制(先获取配置文件中的信息，动态获取信息并创建对象和调用方法)。

获取class对象

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //Class类中的静态方法forName("全类名")
            //全类名：包名+类名
        Class clazz = Class.forName("reflect.Student");
        System.out.println(clazz);

        //通过class属性获取
        Class clazz2 = Student.class;
        System.out.println(clazz2);

        //利用对象的getClass方法来获取class对象
        //getClass方法是定义在Object类中的
        Student s = new Student();
        Class clazz3 = s.getClass();
        System.out.println(clazz3);
    }
}

获取Constructor对象

package reflect2;

public class Student {
    private String name;
    private int age;
    //私有的有参构造方法
    private Student(String name){
        System.out.println("name的值为："+ name);
        System.out.println("private...Studet...有参构造方法");
    }
    //公共的无参构造方法
    public Student(){
        System.out.println("public...Student...无参构造方法");
    }
    //公共的有参构造方法
    public Student(String name,int age){
        System.out.println("name的值为："+name+"age的值为："+age);
        System.out.println("public...Student...有参构造方法");
    }
}

package reflect2;

import java.lang.reflect.Constructor;

public class ReflectTest2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //Constructor<?>[] getConstructors():返回所有公共构造方法对象的数组
        //1.获取class对象
        Class clazz = Class.forName("reflect2.Student");
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("---------------");
        //Constructor<?>[] getDeclaredConstructors():返回所有构造方法对象的数组
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        System.out.println("---------------");
        //Constructor<T> getConstructor(Class<?>...parameterTypes):返回单个公共构造方法对象
        //小括号中，一定要跟构造方法的形参保持一致
        Constructor constructor = clazz.getConstructor();
        System.out.println(constructor);
        Constructor constructor1 = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor1);
        System.out.println("---------------");
        //Constructor<T> getDeclaredConstructor(class<?>...parameterTypes):返回单个构造方法对象
        Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor);
    }
}

利用Constructor创建对象

T newInstance(Object…initargs)：根据指定的构造方法创建对象；

package reflect2;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectTest3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取class对象
        Class clazz = Class.forName("reflect2.Student");
        //获取构造方法对象
        Constructor constructor = clazz.getConstructor(String.class,int.class);
        //利用newInstance创建Student对象
        Student student = (Student) constructor.newInstance("huahua", 18);
        System.out.println(student);
        System.out.println("---------------");
        Constructor constructor1 = clazz.getConstructor();
        Student student1 = (Student) constructor1.newInstance();
        System.out.println(student1);
        System.out.println("---------------");
        //获取一个私有的构造方法并创建对象
        //获取一个私有化的构造方法
        Constructor constructor2 = clazz.getDeclaredConstructor(String.class);
        //被private修饰的成员，不能直接使用
        //如果反射强行获取并使用，需要临时取消访问检查
        constructor2.setAccessible(true);
        //创建对象
        Student student2 = (Student) constructor2.newInstance("huahua");
        System.out.println(student2);
    }
}

小结

获取class对象
- 三种方式-------Class.forName(“全类名”)
获取里面的构造方法对象
- getConstructor(Class<?>…parameterTypes)
- getDeclaredConstructor(Class<?>…parameterTypes)
如果是public的，直接创建对象
- newInstance(Object…initargs)
如果是非public的，需要临时取消检查，然后在创建对象
- setAccessible(boolean) 暴力反射

获取Field对象

Field[] getFields()：返回所有公共成员变量对象的数组
Field[] getDeclaredFields()：返回所有成员变量对象的数组
Field getField(String name)：返回单个公共成员变量对象
Field getDeclaredField(String name)：返回单个成员变量对象

package reflect3;

public class Student {
    public String name;
    public int age;
    public String gender;
    private int money = 300;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", money=" + money +
                '}';
    }
}

package reflect3;

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        //Field[] getFields()：返回所有公共成员变量对象的数组
        //获取class对象
        Class clazz = Class.forName("reflect3.Student");
        //获取Field对象
        Field[] fields = clazz.getFields();
        //遍历
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-----------");
        //Field[] getDeclaredFields()：返回所有成员变量对象的数组
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("-----------");
        //Field getField(String name)：返回单个公共成员变量对象
        //想要获取的成员变量必须是真实存在的，且必须是public修饰的
        Field name = clazz.getField("name");
        System.out.println(name);
        System.out.println("-----------");
        //Field getDeclaredField(String name)：返回单个成员变量对象
        Field money = clazz.getDeclaredField("money");
        System.out.println(money);
    }
}

获取Field对象赋值或获取值

void set(Object obj,Object value)：给obj对象的成员变量赋值为value
Object get(Object obj)：返回由该Field表示的字段在指定对象上的值

package reflect3;

import java.lang.reflect.Field;

public class ReflectTest2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
        //void set(Object obj,Object value)：给obj对象的成员变量赋值为value
        //Object get(Object obj)：返回由该Field表示的字段在指定对象上的值
        //获取class对象
        Class clazz = Class.forName("reflect3.Student");
        //获取name这个Field对象
        Field name = clazz.getField("name");
        //利用set方法进行赋值
            //先创建一个Student对象
        Student student = (Student) clazz.newInstance();
            //有了对象才可以给指定对象进行赋值
        name.set(student,"花花");
        System.out.println(student);
        System.out.println("-------------");

        //获取成员变量Field对象
        Field money = clazz.getDeclaredField("money");
        //取消一下访问检查
        money.setAccessible(true);
        //调用get方法来获取值
            //创建一个对象
            //获取指定对象的money值
        Object o = money.get(student);
        System.out.println(o);
    }
}

反射获取成员方法并运行

获得Method对象

Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name,Class<?>…parameterTypes)：返回单个公共成员方法对象
Method getDeclaredMethod(String name,Class<?>…parameterTypes)：返回单个成员方法对象

package reflect4;

public class Student {
    //私有的，无参返回值
    private void show(){
        System.out.println("私有的show方法，无参返回值");
    }
    //公共的无参无返回值
    public void function1(){
        System.out.println("function1方法，无参无返回值");
    }
    //公共的，有参无返回值
    public void function2(String name){
        System.out.println("function2方法，有参无返回值，参数为"+name);
    }
    //公共的，无参有返回值
    public String function3(){
        System.out.println("functon3方法,无参有返回值");
        return "aaa";
    }
    //公共的，有参有返回值
    public String function4(String name){
        System.out.println("function4方法，有参有返回值,参数为"+name);
        return "bbb";
    }
}

package reflect4;

import java.lang.reflect.Method;

public class ReflectTest1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
        //获取class对象
        Class clazz = Class.forName("reflect4.Student");
        //获取成员方法对象
        Method[] methods = clazz.getMethods();
        //遍历
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------------");
        //Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
        Method[] methods1 = clazz.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
        System.out.println("--------------");
        //Method getMethod(String name,Class<?>...parameterTypes)：返回单个公共成员方法对象
        Method function1 = clazz.getMethod("function1");
        System.out.println(function1);
        System.out.println("--------------");
        //获取一个有形参的方法function2
        Method function2 = clazz.getMethod("function2", String.class);
        System.out.println(function2);
        System.out.println("--------------");
        //Method getDeclaredMethod(String name,Class<?>...parameterTypes)：返回单个成员方法对象
        Method show = clazz.getDeclaredMethod("show");
        System.out.println(show);
    }
}

利用Method对象运行方法

Object invoke(Object obj,Object…args)：运行方法
- 参数一：用obj对象调用该方法
- 参数二：调用方法传递的参数（如果没有就不写）
- 返回值：方法的返回值（如果没有就不写）

package reflect4;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectTest2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //获取class对象
        Class clazz = Class.forName("reflect4.Student");
        //获取里面的Method对象 function4
        Method function4 = clazz.getMethod("function4", String.class);
        //运行function4
            //创建一个Student对象，当作方法的调用者
        Student student = (Student) clazz.newInstance();
            //运行方法
        Object result = function4.invoke(student, "花花");
        System.out.println(result);
    }
}

猫薄荷>3<

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记day25-类加载器及反射

类加载器类加载时机创建类的实例(对象)调用类的类方法（方法为静态方法）访问类或者接口的类变量，或者为该类变量赋值(静态变量)使用反射的方式来强制创建某个类或接口对应的java.lang.Class对象初始化某个类的子类直接使用java.exe命令来运行某个主类类加载的过程加载链接初始化类加载器的分类启动类加载器(Bootstrap Classloader)：虚拟机内置的类加载器；平台类加载器(Platform Classloader)：负责加载JDK中一些特殊的模
复制链接

扫一扫