（Java学习笔记）JavaSE Java反射机制

最新推荐文章于 2024-06-18 03:55:58 发布

小张不会飞

最新推荐文章于 2024-06-18 03:55:58 发布

阅读量418

点赞数

分类专栏： JavaSE笔记文章标签： java 反射

本文链接：https://blog.csdn.net/qq_43110389/article/details/105627583

版权

JavaSE笔记专栏收录该内容

18 篇文章 5 订阅

订阅专栏

Java反射机制

1、反射机制概述
2、Class类
3、创建运行时类的对象(重点)
4、获取运行时类的完整结构
5、调用运行时类的指定结构（重点）

1、反射机制概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

理解：类的加载过程：

程序经过javac.exe命令进行编译后，会在本地生成一个或多个字节码文件(一个类对应一个字节码文件，以.class结尾)，然后通过使用java.exe命令对某个字节码文件进行解释运行，相当于将该字节码文件加载到内存中，此过程被称为类的加载，加载到内存中的类，我们就成为运行时类，此运行时类，就可以作为Class类的一个实例。

即类也可以作为对象

1.1、动态语言 vs 静态语言

动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
静态语言与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、 C++。

注：Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活！

1.2、Java反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

1.3、反射相关的主要API

java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
… …

2、Class类

2.1、Class类的理解

Class类也被称为描述类的类

在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()。以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
- Class本身也是一个类
- Class 对象只能由系统建立对象
- 一个加载的类在 JVM 中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class对象

2.2、获取Class类的实例(四种方法)（重点）

package com.zck.reflection;

import org.junit.Test;

/**
 * 获取Class实例的四种方式
 *
 * @author zck
 * @create 2020-04-19 13:47
 */
public class ClassTest {
    @Test
    public void test1() throws ClassNotFoundException {
        //方式一:调用运行时类的属性 .class
        Class<Person> clazz1 = Person.class;
        System.out.println(clazz1);
        //方式二：通过运行时类的对象，调用getClass()
        Person p1 = new Person();
        Class<? extends Person> clazz2 = p1.getClass();
        System.out.println(clazz2);
        //方式三(主要)：调用Class的静态方法:forName(String  classPath)
        Class<?> clazz3 = Class.forName("com.zck.reflection.Person");
//        Class<?> clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);
        //说明：加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式获取此运行时类。
        System.out.println(clazz1 == clazz3);//true
        System.out.println(clazz2 == clazz3);//true

        //方式四（了解）：使用类的加载器 ClassLoader
        ClassLoader classLoader = ClassTest.class.getClassLoader();
        Class<?> clazz4 = classLoader.loadClass("com.zck.reflection.Person");
        System.out.println(clazz4);
        System.out.println(clazz1 == clazz4);//true
    }
}

2.3、哪些类型可以有Class对象

（1）class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
（2）interface：接口
（3）[]：数组
（4）enum：枚举
（5）annotation：注解@interface
（6）primitive type：基本数据类型
（7）void

public void test2(){
        Class<Object> c1 = Object.class;
        Class<Comparable> c2 = Comparable.class;
        Class<String[]> c3 = String[].class;
        Class<int[][]> c4 = int[][].class;
        Class<ElementType> c5 = ElementType.class;
        Class<Override> c6 = Override.class;
        Class<Integer> c7 = int.class;
        Class<Void> c8 = void.class;
        Class<Class> c9 = Class.class;
        int[] a = new int[10];
        int[] b = new int[100];
        Class<? extends int[]> c10 = a.getClass();
        Class<? extends int[]> c11 = b.getClass();
        // 只要元素类型与维度一样，就是同一个Class
        System.out.println(c10 == c11);
}

2.4、配置文件的读取(重点)

package com.zck.reflection;

import org.junit.Test;

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

/**
 * @author zck
 * @create 2020-04-19 14:41
 */
public class PropertiesTest {
    @Test
    public void test1() throws IOException {
        Properties pros = new Properties();
        //方式一：此时文件默认在module下
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        pros.load(fis);

        //方式二：此时的文件在module下的src下
        ClassLoader classLoader = PropertiesTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ",password = " + password);

    }
}

3、创建运行时类的对象(重点)

调用Class对象的newInstance()

    //通过反射创建对应的运行时类的对象
    @Test
    public void test1() throws IllegalAccessException, InstantiationException {
        Class<Person> clazz = Person.class;
        /*
        newInstance():调用此方法，创建对应的运行时类的对象
        内部调用了运行时类的空参构造器
        要想此方法正常创建运行时类的对象 要求：
            1.运行时类必须创建空参构造器
            2.空参构造器的访问权限得够，通常设置为public
         */
        Person person = clazz.newInstance();
        System.out.println(person);
    }

4、获取运行时类的完整结构

通过反射获取运行时类的完整结构 Field、Method、Constructor、Superclass、Interface、Annotation

1.实现的全部接口 public Class[] getInterfaces() 确定此对象所表示的类或接口实现的接口。
2.所继承的父类 public Class getSuperclass() 返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。
3.全部的构造器

public Constructor[] getConstructors() 返回此 Class 对象所表示的类的所有public构造方法。

public Constructor[] getDeclaredConstructors() 返回此 Class 对象表示的类声明的所有构造方法。 Constructor类中：

取得修饰符: public int getModifiers();

取得方法名称: public String getName();

取得参数的类型：public Class[] getParameterTypes();
4.全部的方法

public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法

public Method[] getMethods() 返回此Class对象所表示的类或接口的public的方法

Method类中：

public Class getReturnType()取得全部的返回值

public Class[] getParameterTypes()取得全部的参数

public int getModifiers()取得修饰符

public Class[] getExceptionTypes()取得异常信息
5.全部的Field

public Field[] getFields() 返回此Class对象所表示的类或接口的public的Field。

public Field[] getDeclaredFields() 返回此Class对象所表示的类或接口的全部Field。

Field方法中：

public int getModifiers() 以整数形式返回此Field的修饰符

public Class getType() 得到Field的属性类型

public String getName() 返回Field的名称。
6.Annotation相关

get Annotation(Class annotationClass)

getDeclaredAnnotations()
7.泛型相关
获取父类泛型类型：Type getGenericSuperclass()

泛型类型：ParameterizedType

获取实际的泛型类型参数数组：getActualTypeArguments()
8.类所在的包 Package getPackage()

5、调用运行时类的指定结构（重点）

5.1、调用指定属性

@Test
    public void test() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class<Person> clazz = Person.class;
        //创建运行时类对象
        Person p1 = clazz.newInstance();
        //获取指定属性
        //方式一：getField(String name)：要求属性为public的。（通常不采用此方式）
//        Field id = clazz.getField("id");
        //方式二:1.getDeclaredField(String name):获取指定变量名的属性 推荐
        Field id1 = clazz.getDeclaredField("id");
        //2.保证当前属性可访问
        id1.setAccessible(true);

        //3.设置当前属性的值
//        id.set(p1,10001);//set():参数1：指明设置那个对象的属性，参数2：将此属性值设置为多少
        id1.set(p1,1001);
//        int pId = (int) id.get(p1);
        int pId1 = (int) id1.get(p1);
//        System.out.println(pId);
        System.out.println(pId1);

    }

5.2、调用指定方法（重点）

@Test
    public void test1() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<Person> clazz = Person.class;
        Person p1 = clazz.newInstance();
        //1.获取指定的某个方法  showNation() :非静态
        //getDeclaredMethod(String name,Class…parameterTypes),name:方法名，parameterTypes：获取方法的形参列表
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        //设置当前方法可被访问
        showNation.setAccessible(true);
        // 访问：invoke(Object obj, Object … args),obj:该方法的调用者，args：实参
        //invoke()的返回值 即为对应运行是类 p1 调用的方法 showNation() 的返回值
        String returnValue = (String) showNation.invoke(p1, "中国");
        System.out.println(returnValue);

        //调用静态方法  ：showDesc()
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
//        Object returnValue1 = showDesc.invoke(Person.class);
        Object returnValue1 = showDesc.invoke(null);
        //若此方法无返回值，则返回invoke()返回null
        System.out.println(returnValue1);//null

    }

5.3、调用指定构造器(不常用)

  @Test
    public void test2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Person> clazz = Person.class;
        //调用private Person(String name) 构造器
        //1.获取指定的构造器:
        Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);//参数：指明构造器的参数列表
        //2.设置当前构造器可被访问
        constructor.setAccessible(true);
        //3.使用该构造器创建运行时类的对象
        Person p1 = constructor.newInstance("Jerry");//参数：设置的属性值
        System.out.println(p1);//Person{name='Jerry', age=0}
    }

注：本文章是根据哔哩哔哩公开课 Java -Java 学习- Java 基础到高级-宋红康-零基础自学Java-尚硅谷整理所得
大爱康师傅！！！

小张不会飞

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
（Java学习笔记）JavaSE Java反射机制

Java反射机制1、反射机制概述1.1、动态语言 vs 静态语言1.2、Java反射机制提供的功能1.3、反射相关的主要API2、Class类2.1、Class类的理解2.2、获取Class类的实例(四种方法)（重点）2.3、哪些类型可以有Class对象2.4、配置文件的读取(重点)3、创建运行时类的对象(重点)4、获取运行时类的完整结构5、调用运行时类的指定结构（重点）5.1、调用指定属性5.2...
复制链接

扫一扫

专栏目录