JavaSE进阶14：类加载器、反射

XXXZhy

已于 2022-04-28 21:18:44 修改

阅读量400

点赞数

分类专栏： JAVA进阶笔记文章标签： JAVA

于 2022-04-25 11:25:13 首次发布

本文链接：https://blog.csdn.net/qq_35982918/article/details/124374766

版权

JAVA进阶笔记专栏收录该内容

18 篇文章 9 订阅

订阅专栏

系列文章目录

JavaSE进阶01：继承、修饰符
 JavaSE进阶02：多态、抽象类、接口
 JavaSE进阶03：内部类、Lambda表达式
 JavaSE进阶04：API中常用工具类
 JavaSE进阶05：包装类、递归、数组的高级操作、异常
 JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
 JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
 JavaSE进阶09：Stream流、File类
 JavaSE进阶10：IO流、字节流、字节缓冲流
 JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
 JavaSE进阶12：多线程、线程同步、线程池
 JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
 JavaSE进阶14：类加载器、反射
 JavaSE进阶15：XML、注解、单元测试
 JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
 Java进阶作业

1.类加载器

1.1类加载器【理解】

作用

负责将.class文件（存储的物理文件）加载在到内存中

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hKeEu84Q-1650762063459)(.\img\01_类加载器.png)]$

1.2类加载的过程【理解】

类加载时机：用到就加载，不用不加载
1. 创建类的实例（对象）
2. 调用类的类方法（静态方法）
3. 访问类或者接口的类变量（静态变量），或者为该类变量赋值
4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
5. 初始化某个类的子类
6. 直接使用java.exe命令来运行某个主类
类加载过程
1. 加载
  - 通过包名 + 类名，获取这个类，准备用流进行传输
  - 在这个类加载到内存中
  - 加载完毕创建一个class对象
2. 链接
  2.1 验证
  
  确保Class文件字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全
  
  (文件中的信息是否符合虚拟机规范有没有安全隐患)
  
  2.2 准备
  
  负责为类的类变量（被static修饰的变量）分配内存，并设置默认初始化值
  
  (初始化静态变量)
  
  2.3 解析
  
  将类的二进制数据流中的符号引用替换为直接引用
  
  (本类中如果用到了其他类，此时就需要找到对应的类)
  
  如：String在加载时是符号，解析后才加入String
3. 初始化
  
  根据程序员通过程序制定的主观计划去初始化类变量和其他资源
  
  (静态变量赋值以及初始化其他资源)
小结
- 当一个类被使用的时候，才会加载到内存，不用不加载
- 类加载的过程: 加载、验证、准备、解析、初始化

1.3类加载的分类【理解】

分类
- Bootstrap class loader：虚拟机的内置类加载器，通常表示为null ，并且没有父null
- Platform class loader：平台类加载器,负责加载JDK中一些特殊的模块
- System class loader：系统类加载器,负责加载用户类路径上所指定的类库
类加载器的组成关系
- System的父加载器为Platform
- Platform的父加载器为Bootstrap

public class ClassLoaderDemo1 {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        //获取系统类加载器的父加载器 --- 平台类加载器
        ClassLoader classLoader1 = systemClassLoader.getParent();

        //获取平台类加载器的父加载器 --- 启动类加载器
        ClassLoader classLoader2 = classLoader1.getParent();

        System.out.println("系统类加载器" + systemClassLoader);
        System.out.println("平台类加载器" + classLoader1);
        System.out.println("启动类加载器" + classLoader2);

    }
}
/*
系统类加载器jdk.internal.loader.ClassLoaders$AppClassLoader@3fee733d
平台类加载器jdk.internal.loader.ClassLoaders$PlatformClassLoader@506e1b77
启动类加载器null
 */

1.4双亲委派模型【理解】

介绍

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式

在这里插入图片描述

1.5ClassLoader 中的两个方法【应用】

方法介绍

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

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

package com.xxx.zzz;

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

public class ClassLoaderDemo2 {
    public static void main(String[] args) throws IOException {

        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        //利用加载器去加载一个指定的文件
        //参数：文件的路径（放在src的根目录下，默认去那里加载）
        //返回值：字节流。
        InputStream is = systemClassLoader.getResourceAsStream("prop.properties");

        Properties prop = new Properties();
        prop.load(is);

        System.out.println(prop);

        is.close();
    }
}
/*
prop.properties
{name=src, age=14}

com/xxx/zzz/prop.properties
{name=com.xxx.zzz, age=14}

com/xxx/yyy/prop.properties
{name=com.xxx.yyy, age=14}

com/xxx/zzz/aaa/prop.properties
{name=com.xxx.zzz.aaa, age=14}
 */

总结：prop.properties只能放在src和src下的其他包，放在其他位置都不能使用getResourceAsStream方法，getResourceAsStream默认读取src下的配置文件
在这里插入图片描述

2.反射

2.1反射的概述【理解】

正射：直接创建对象就是正射
反射的概念：反射是java的一种机制，让我们在运行的时候获取到类的信息。
反射的作用：利用反射可以无视修饰符获取类里面所有的属性和方法。先获取配置文件中的信息，动态获取信息并创建对象和调用方法。
区别：正射先创建对象获取属性，再编译成class文件。反射是先获取内存中的class文件，通过Class对象获取里面的属性和方法。

2.2获取Class类对象的三种方式【应用】

三种方式分类
- 类名.class属性
- 对象名.getClass()方法
- Class.forName(全类名)方法
思路
- 通过Student类或者stu对象获得Class类，然后通过Class类获取Student类中的信息，比如属性、方法、构造等。

/*学生类*/
package com.xxx.javabean;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void study(){
        System.out.println("学生在学习");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/*测试类*/
package com.xxx.myreflect;//ReflectDemo1在com.xxx.myreflect包
import com.xxx.javabean.Student;//导入com.xxx.javabean包下的Student

public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class类中的静态方法forName("全类名")
        //全类名:包名 + 类名
        Class c1 = Class.forName("com.xxx.javabean.Student");
        System.out.println(c1);

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

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

        System.out.println(c1 == c2);
        System.out.println(c3 == c2);
    }
}
/*
class com.xxx.javabean.Student
class com.xxx.javabean.Student
class com.xxx.javabean.Student
true
true
 */

2.3反射获取构造方法并使用【应用】

2.3.1Class类获取构造方法对象的方法

方法介绍

方法名	说明
Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组，包括私有
Constructor getConstructor(Class<?>… parameterTypes)	返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class<?>… parameterTypes)	返回单个构造方法对象，可以私有

/*老师类*/
package com.xxx.javabean;

public class Teacher {
    private String name;
    private int age;

    //私有的有参构造方法
    private Teacher(String name) {
        System.out.println("name的值为:" + name);
        System.out.println("private...Teacher...有参构造方法");
    }

    //公共的无参构造方法
    public Teacher() {
        System.out.println("public...Teacher...无参构造方法");
    }

    //公共的有参构造方法
    public Teacher(String name, int age) {
        System.out.println("name的值为:" + name + "---age的值为:" + age);
        System.out.println("public...Teacher...有参构造方法");
    }
}


/*测试类*/
package com.xxx.myreflect;
import java.lang.reflect.Constructor;

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        method1();
        method2();
        method3();
        method4();
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        System.out.println("----------getDeclaredConstructor(Class<?>... parameterTypes)返回单个构造方法对象,可私有----------");
        Class clazz = Class.forName("com.xxx.javabean.Teacher");
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        System.out.println(constructor);
    }

    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        System.out.println("----------getConstructor(Class<?>... parameterTypes)返回单个公共构造方法对象----------");
        Class clazz = Class.forName("com.xxx.javabean.Teacher");

        //小括号中,一定要跟构造方法的形参保持一致
        Constructor constructor1 = clazz.getConstructor();
        System.out.println(constructor1);

        Constructor constructor2 = clazz.getConstructor(String.class, int.class);//注意要.class
        System.out.println(constructor2);

        //因为Student类中,没有只有一个int的构造,所以这里会报错Exception in thread "main" java.lang.NoSuchMethodException: com.xxx.javabean.Teacher.<init>(int)
        //Constructor constructor3 = clazz.getConstructor(int.class);
        //System.out.println(constructor3);
    }

    private static void method2() throws ClassNotFoundException {
        System.out.println("----------getDeclaredConstructors()返回所有构造方法对象的数组，包括私有----------");
        Class clazz = Class.forName("com.xxx.javabean.Teacher");
        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }

    private static void method1() throws ClassNotFoundException {
        System.out.println("----------getConstructors()返回所有公共构造方法对象的数组----------");
        Class clazz = Class.forName("com.xxx.javabean.Teacher");
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }
}
/*
----------getConstructors()返回所有公共构造方法对象的数组----------
public com.xxx.javabean.Teacher()
public com.xxx.javabean.Teacher(java.lang.String,int)
----------getDeclaredConstructors()返回所有构造方法对象的数组，包括私有----------
private com.xxx.javabean.Teacher(java.lang.String)
public com.xxx.javabean.Teacher()
public com.xxx.javabean.Teacher(java.lang.String,int)
----------getConstructor(Class<?>... parameterTypes)返回单个公共构造方法对象----------
public com.xxx.javabean.Teacher()
public com.xxx.javabean.Teacher(java.lang.String,int)
----------getDeclaredConstructor(Class<?>... parameterTypes)返回单个构造方法对象,可私有----------
private com.xxx.javabean.Teacher(java.lang.String)
 */

2.3.2Constructor类用于创建对象的方法

方法介绍

方法名说明
T newInstance(Object…initargs) 根据指定的构造方法创建对象
setAccessible(boolean flag) 设置为true,表示取消访问检查

方法名	说明
T newInstance(Object…initargs)	根据指定的构造方法创建对象
setAccessible(boolean flag)	设置为true,表示取消访问检查

// Teacher类同上一个示例
package com.xxx.myreflect;
import com.xxx.javabean.Teacher;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //T newInstance(Object... initargs)：根据指定的构造方法创建对象
        method1();
        method2();
        method3();
        method4();
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        System.out.println("---------获取一个私有的构造方法并创建对象--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Teacher");

        //2.获取一个私有化的构造方法.
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //被private修饰的成员,不能直接使用的
        //如果用反射强行获取并使用,需要临时取消访问检查,即我要强制访问
        constructor.setAccessible(true);

        //3.直接创建对象
        Teacher teacher = (Teacher) constructor.newInstance("zhangsan");

        System.out.println(teacher);
    }

    private static void method3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        System.out.println("---------利用空参构造来创建Teacher的对象(简写格式不建议用)--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Teacher");

        //2.在Class类中,有一个newInstance方法,可以利用空参直接创建一个对象
        Teacher teacher = (Teacher) clazz.newInstance();//这个方法现在已经过时了,了解一下

        System.out.println(teacher);
    }

    private static void method2() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, InvocationTargetException {
        System.out.println("---------利用空参构造来创建Teacher的对象--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Teacher");

        //2.获取构造方法对象
        Constructor constructor = clazz.getConstructor();

        //3.利用空参来创建Teacher的对象
        Teacher teacher = (Teacher) constructor.newInstance();

        System.out.println(teacher);
    }

    private static void method1() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        System.out.println("---------利用有参构造来创建Teacher的对象--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Teacher");

        //2.获取构造方法对象
        Constructor constructor = clazz.getConstructor(String.class, int.class);

        //3.利用newInstance创建Teacher的对象
        Teacher teacher = (Teacher) constructor.newInstance("zhangsan", 23);

        System.out.println(teacher);
    }
}
/*
---------利用有参构造来创建Teacher的对象--------
name的值为:zhangsan---age的值为:23
public...Teacher...有参构造方法
com.xxx.javabean.Teacher@30dae81
---------利用空参构造来创建Teacher的对象--------
public...Teacher...无参构造方法
com.xxx.javabean.Teacher@1b2c6ec2
---------利用空参构造来创建Teacher的对象(简写格式不建议用)--------
public...Teacher...无参构造方法
com.xxx.javabean.Teacher@4edde6e5
---------获取一个私有的构造方法并创建对象--------
name的值为:zhangsan
private...Teacher...有参构造方法
com.xxx.javabean.Teacher@50040f0c
 */

2.3.3小结

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

2.4反射获取成员变量并使用【应用】

2.4.1Class类获取成员变量对象的方法

方法分类

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组，包括私有
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象，可以私有

/*朋友类*/
package com.xxx.javabean;
public class Friend {
    public String name;
    public int age;
    public String address;
    private int money = 300;

    @Override
    public String toString() {
        return "Friend{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", money=" + money +
                '}';
    }
}



/*测试类*/
package com.xxx.myreflect;
import java.lang.reflect.Field;
public class ReflectDemo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        method1();
        method2();
        method3();
        method4();
    }

    private static void method4() throws ClassNotFoundException, NoSuchFieldException {
        System.out.println("------Field getDeclaredField(String name)：返回单个成员变量对象，可以私有------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Friend");
        //2.获取money成员变量
        Field field = clazz.getDeclaredField("money");

        System.out.println(field);
    }

    private static void method3() throws ClassNotFoundException, NoSuchFieldException {
        System.out.println("------Field getField(String name)：返回单个公共成员变量对象------");

        //想要获取的成员变量必须是真实存在的，且必须是public修饰的.
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Friend");
        //2.获取name这个成员变量
        Field field = clazz.getField("name");
        //Field field = clazz.getField("name1");//不存在变量报错：Exception in thread "main" java.lang.NoSuchFieldException: name1
        //Field field = clazz.getField("money");//私有变量报错：Exception in thread "main" java.lang.NoSuchFieldException: money

        //3.打印一下
        System.out.println(field);
    }

    private static void method2() throws ClassNotFoundException {
        System.out.println("------Field[] getDeclaredFields()：返回所有成员变量对象的数组，包括私有------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Friend");

        //2.获取所有的Field对象
        Field[] fields = clazz.getDeclaredFields();

        //3.遍历
        for (Field field : fields) {
            System.out.println(field);
        }
    }

    private static void method1() throws ClassNotFoundException {
        System.out.println("------Field[] getFields()：返回所有公共成员变量对象的数组------");

        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Friend");

        //2.获取Field对象.
        Field[] fields = clazz.getFields();

        //3.遍历
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}
/*
------Field[] getFields()：返回所有公共成员变量对象的数组------
public java.lang.String com.xxx.javabean.Friend.name
public int com.xxx.javabean.Friend.age
public java.lang.String com.xxx.javabean.Friend.address
------Field[] getDeclaredFields()：返回所有成员变量对象的数组，包括私有------
public java.lang.String com.xxx.javabean.Friend.name
public int com.xxx.javabean.Friend.age
public java.lang.String com.xxx.javabean.Friend.address
private int com.xxx.javabean.Friend.money
------Field getField(String name)：返回单个公共成员变量对象------
public java.lang.String com.xxx.javabean.Friend.name
------Field getDeclaredField(String name)：返回单个成员变量对象，可以私有------
private int com.xxx.javabean.Friend.money
 */

2.4.2Field类用于给成员变量赋值的方法

方法介绍

方法名说明
void set(Object obj, Object value) 赋值
Object get(Object obj) 获取值

方法名	说明
void set(Object obj, Object value)	赋值
Object get(Object obj)	获取值

// Friend类同上一个示例
package com.xxx.myreflect;
import com.xxx.javabean.Friend;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectDemo5 {
    public static void main(String[] args) throws Exception{
        //        Object get(Object obj) 返回由该 Field表示的字段在指定对象上的值。
        //        void set(Object obj, Object value)：给obj对象的成员变量赋值为value
        method1();
        method2();
    }

    private static void method2() throws Exception {
        System.out.println("--------给obj对象的private成员变量赋值--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Friend");

        //2.获取私有private成员变量Field的对象
        Field field = clazz.getDeclaredField("money");

        //3.取消一下访问检查
        field.setAccessible(true);

        //4.调用get方法来获取值
            //4.1创建一个对象
        Constructor constructor = clazz.getConstructor();
        Friend friend = (Friend)constructor.newInstance();
            //4.2获取指定对象的money的值
        Object o = field.get(friend);

        //5.打印私有变量原值
        System.out.println(o);

        //6.更改私有变量值并打印
        field.set(friend, 100);
        System.out.println(friend);
    }

    private static void method1() throws Exception{
        System.out.println("--------给obj对象的public成员变量赋值--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Friend");

        //2.获取公共的name这个Field对象
        Field field = clazz.getField("name");

        //3.利用set方法进行赋值.
            //3.1先创建一个Friend对象
        Constructor constructor = clazz.getConstructor();
        Friend friend = (Friend)constructor.newInstance() ;
            //3.2有了对象才可以给指定对象进行赋值
        field.set(friend,"zhangsan");

        //4.打印
        System.out.println(field.get(friend));
        System.out.println(friend);

    }
}
/*
zhangsan
Friend{name='zhangsan', age=0, address='null', money=300}
--------给obj对象的private成员变量赋值--------
300
Friend{name='null', age=0, address='null', money=100}
 */

2.5反射获取成员方法并使用【应用】

2.5.1Class类获取成员方法对象的方法

方法分类

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

/*人类类*/
package com.xxx.javabean;
public class Person {
    //私有的，无参无返回值
    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("function3方法，无参有返回值");
        return "aaa";
    }

    //公共的，有参有返回值
    public String function4(String name) {
        System.out.println("function4方法，有参有返回值,参数为" + name);
        return "aaa";
    }
}

/*测试类*/
package com.xxx.myreflect;
import java.lang.reflect.Method;

public class ReflectDemo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        method1();
        method2();
        method3();
        method4();
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        System.out.println("--------Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回单个成员方法对象，可私有--------");

        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Person");
        //2.获取一个成员方法show
        Method method = clazz.getDeclaredMethod("show");
        Method method2 = clazz.getDeclaredMethod("function4",String.class);

        //3.打印一下
        System.out.println("私有的，无参无返回值："+method);
        System.out.println("公共的，有参有返回值:"+method2);
    }


    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        System.out.println("--------Method getMethod(String name, Class<?>... parameterTypes) 返回单个公共成员方法对象--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Person");
        //2.获取成员方法
        Method method1 = clazz.getMethod("function1");
        Method method2 = clazz.getMethod("function2", String.class);
        Method method3 = clazz.getMethod("function3");
        //3.打印一下
        System.out.println("公共的，无参无返回值:"+method1);
        System.out.println("公共的，有参无返回值:"+method2);
        System.out.println("公共的，无参有返回值:"+method3);
    }

    private static void method2() throws ClassNotFoundException {
        System.out.println("--------Method[] getDeclaredMethods() 返回所有成员方法对象的数组，不包括继承的，包括私有--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Person");
        //2.获取Method对象
        Method[] methods = clazz.getDeclaredMethods();
        //3.遍历一下数组
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    private static void method1() throws ClassNotFoundException {
        System.out.println("--------Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的--------");
        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Person");
        //2.获取成员方法对象
        Method[] methods = clazz.getMethods();//父类也会获得
        //3.遍历
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}
/*
--------Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的--------
public void com.xxx.javabean.Person.function1()
public java.lang.String com.xxx.javabean.Person.function3()
public void com.xxx.javabean.Person.function2(java.lang.String)
public java.lang.String com.xxx.javabean.Person.function4(java.lang.String)
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
--------Method[] getDeclaredMethods() 返回所有成员方法对象的数组，不包括继承的，包括私有--------
public void com.xxx.javabean.Person.function1()
public java.lang.String com.xxx.javabean.Person.function3()
public void com.xxx.javabean.Person.function2(java.lang.String)
private void com.xxx.javabean.Person.show()
public java.lang.String com.xxx.javabean.Person.function4(java.lang.String)
--------Method getMethod(String name, Class<?>... parameterTypes) 返回单个公共成员方法对象--------
公共的，无参无返回值:public void com.xxx.javabean.Person.function1()
公共的，有参无返回值:public void com.xxx.javabean.Person.function2(java.lang.String)
公共的，无参有返回值:public java.lang.String com.xxx.javabean.Person.function3()
--------Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回单个成员方法对象，可私有--------
私有的，无参无返回值：private void com.xxx.javabean.Person.show()
公共的，有参有返回值:public java.lang.String com.xxx.javabean.Person.function4(java.lang.String)
 */

2.5.2Method类用于执行方法的方法

方法介绍

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

方法名	说明
Object invoke(Object obj, Object… args)	运行方法

//Person类同上一个例子
package com.xxx.myreflect;
import com.xxx.javabean.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo7 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        //1.获取class对象
        Class clazz = Class.forName("com.xxx.javabean.Person");
        //2.获取里面的Method对象  function4
        Method method = clazz.getMethod("function4", String.class);
        //3.运行function4方法就可以了
        //3.1创建一个Student对象,当做方法的调用者
        Constructor constructor = clazz.getConstructor();
        Person person = (Person)constructor.newInstance();
        //3.2运行方法
        Object result = method.invoke(person, "zhangsan");
        //4.打印一下返回值
        System.out.println("返回值："+result);
    }
}
/*
function4方法，有参有返回值,参数为zhangsan
返回值：aaa
 */

XXXZhy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE进阶14：类加载器、反射

1.类加载器1.1类加载器【理解】作用负责将.class文件（存储的物理文件）加载在到内存中[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hKeEu84Q-1650762063459)(.\img\01_类加载器.png)]1.2类加载的过程【理解】类加载时机创建类的实例（对象）调用类的类方法访问类或者接口的类变量，或者为该类变量赋值使用反射方式来强制创建某个类或接口对应的java.lang.Class对象初始化某个类的子类直接使用jav
复制链接

扫一扫