【JavaSE】之反射

最新推荐文章于 2023-05-07 00:43:23 发布
最新推荐文章于 2023-05-07 00:43:23 发布
阅读量173 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gx123456sh/article/details/86812632
版权

1.认识反射机制

1.1初识反射

反射指得是对象的反向处理。根据对象倒推类的组成。

例：观察正常处理

import java.util.Date;

public class Test{
    public static void main(String[] args){
        Date date = new Date();
    }
}

所谓的“反”指的是根据对象来取得对象的来源信息，反射的核心处理在于Object类的一个方法：取得类的class对象

public final native Class<?> getClass();

该方法返回的是一个Class对象，这个Class描述的就是类。

在反射的世界里，看中的不再是一个对象，而是对象身后的组成（构造方法、普通方法、普通属性）。

1.2Class对象的三种实例化方式

任何一个类的Class对象由JVM加载类后产生（该对象在JVM中全局唯一），用户只能调用指定方法来取得该对象。

I.任何类的对象可以通过Object类提供的getClass（）取得该类的Class对象。

II.“类名称.class”可以直接根据某个具体类来取得其Class对象

III.调用Class类的静态方法Class.forName（String className）传入类的全名称来取得其Class对象

public class Test2{
    public static void main(String[] args) throws ClassNotFoundException {
        //根据类正向产生对象
        Date date = new Date();
        //1.通过类对象.getClass()
        System.out.println(date.getClass());
        //2.通过类名称.class
        System.out.println(Date.class);
        //3.通过调用Class类提供的静态方法forName(String className)
        System.out.println(Class.forName("java.util.Date"));
    }
}

取得一个类的Class对象后：可以通过反射来实例化对象

在Class类中有如下方法：只能调用类中无参构造且无参构造必须是public权限

public T[Object] newInstance() throws InstantiationException,IllegalAccessException
public class Test2{
    public static void main(String[] args) throws Exception {
        //Date date = new Date();
        //1.取得类的Class对象
        Class<Date> cls = (Class<Date>)Class.forName("java.util.Date");
        //通过反射取得Date类实例化对象
        Date date = cls.newInstance();
        System.out.println(date);
    }
}

例：使用反射实现简单工厂

interface IFruit{
    void eat();
}

class Apple implements IFruit{
    @Override
    public void eat() {
        System.out.println("eat an apple");
    }
}
class Pear implements IFruit{
    @Override
    public void eat() {
        System.out.println("eat a pear");
    }
}
//反射修改工厂方法
class Factory{
    private Factory(){}
    //工厂方法模式
    public static IFruit getInstance(String className){
        IFruit fruit = null;
        try {
            //取得任意子类反射对象
            Class<?> cls = Class.forName(className);
            //通过反射取得实例化对象
            fruit = (IFruit) cls.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fruit;
    }
}
public class Test2{
    public static void main(String[] args) {
        IFruit fruit = Factory.getInstance("www.bit.java.Pear");
        fruit.eat();
    }
}

2.反射与类操作（与反射相关的第一步都是取得Class对象）

2.1反射取得父类、父接口信息

2.1.1取得类的包名称

public Package getPackage();

例：

public class Test2{
    public static void main(String[] args) throws Exception {
        //1.取得Class对象
        Class<?> cls = Date.class;
        //只取得包名，不要版本号
        System.out.println(cls.getPackage().getName());
    }
}

2.1.2取得父类的Class对象（父类单继承，只可能有一个）

public native Class<? super T> getSuperClass();

2.1.3取得实现的父接口（可以实现多个接口）

public Class<?>[] getInterfaces();

例：

class Person{}
interface INews{}
interface IMessage{}

class Student extends Person implements INews,IMessage{}

public class Test2{
    public static void main(String[] args) throws Exception {
        Class<?> cls = Student.class;
        System.out.println(cls.getSuperclass().getName());
        Class<?>[] classes = cls.getInterfaces();
        for(Class<?> classs : classes){
            System.out.println(classs.getName());
        }
    }
}

注意：基本数据类型在JVM中也有类对象

Class<?> cls = int.class;
Class<?> cls1 = Integer.class;
System.out.println(cls);
System.out.println(cls1);

2.2反射调用类中构造方法-Constructor（描述类中构造方法）

取得类中指定参数类型的构造方法

//只能取得类中public权限的构造方法
public Constructor<T> getConstructor(Class<?> ... parameterTypes)
//可以取得类中全部构造方法，包含私有构造
public Constructor<T> getDeclaredConstructor(Class<?> ... parameterTypes)

取得类中所有构造方法

//只能取得类中public权限的构造方法
public Constructor<?>[] getConstructors() throws SecurityException
//可以取得类中全部构造方法，包含私有构造
public Constructor<?>[] getDeclaredConstructors() throws SecurityException

例：

class Person{
    private Person(){}
    protected Person(String name){}
    public Person(String name, int age){}
}
public class Test2{
    public static void main(String[] args) throws Exception {
        Class<?> cls = Person.class;
        {
            Constructor<?>[] constructors = cls.getConstructors();
            for(Constructor<?> constructor : constructors){
                System.out.println(constructor);
            }
        }
        System.out.println("-------------------------------");
        {
            Constructor<?>[] constructors = cls.getDeclaredConstructors();
            for(Constructor<?> constructor : constructors){
                System.out.println(constructor);
            }
        }
    }
}

Constructor类提供了实例化对象的方法：

public T newInstance(Object ... initargs)：可以调用类中其他有参构造

Class类提供实例化对象的方法：

public T(Object) newInstance()：只能调用无参构造，且无参构造必须是public权限

例：

class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test2{
    public static void main(String[] args) throws Exception {
        Class<?> cls = Person.class;
        Constructor<?> constructor = cls.getDeclaredConstructor(String.class, int.class);
        Person per = (Person) constructor.newInstance("zhangan",45);
        System.out.println(per);
    }
}

        如果将有参构造的public改为private，getDeclaredConstructor虽然可以拿到此方法，但是不能在Person类外部new一个对象。会出现访问权限异常。

2.3反射调用类中普通方法-Method（描述类中普通方法）

取得类中指定名称的普通方法

public Method getMethod(String name，Class<?> ... parameterTypes)
public Method getDeclearedMethod(String name，Class<?> ... parameterTypes)

取得类中全部普通方法

//取得本类以及父类中所有public方法
public Method[] getMethods() throws SecurityException
//取得本类中全部普通方法，包含私有方法
public Method[] getDeclearedMethods() throws SecurityException

例：

class Person{
    private void test(){}
    protected void fun(){}
    public void haha(){}
}
class Student extends Person{
    private void test1(){}
    protected void fun1(){}
    public void haha1(){}
}
public class Test2{
    public static void main(String[] args) {
        Class<?> cls = Student.class;
        {
            Method[] methods = cls.getMethods();
            for(Method method : methods){
                System.out.println(method);
            }
        }
        System.out.println("------------------------");
        {
            Method[] methods = cls.getDeclaredMethods();
            for(Method method : methods){
                System.out.println(method);
            }
        }
    }
}

Method类中提供调用类中普通方法的API

public Object invoke(Object obj,Object ... args)
class Person{
    private String name;
    private int age;
    public Person(){}
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 class Test2{
    public static void main(String[] args) throws Exception {
        //1.拿到PersonClass对象
        Class<?> cls = Person.class;
        //2.创建Person实例化对象
        Person per = (Person) cls.newInstance();
        //3.拿到setName的Method对象
        Method setMethod = cls.getMethod("setName",String.class);
        //4.通过invoke进行调用
        setMethod.invoke(per,"zhangsan");
        System.out.println(per);
    }
}

2.4反射调用类中属性Field（描述类中普通属性）

取得类中指定属性

public Field getField(String name)
public Field getDeclaredField(String name)

取得类中全部属性

//取得本类以及父类中所有public属性
public Field[ ] getFields() throws SecurityException
//取得本类中全部属性，包含私有属性
public Field[ ] getDeclaredFields() throws SecurityException

Field类提供设置与取得属性方法：

设置属性：

public void set(Object obj，Object value)

取得属性：

public Object get(Object obj)

取得属性类型：

public Class<?> getType()

2.5动态设置封装

Constructor、Method、Field类都是AccessibleObject子类。

AccessibleObject提供动态设置封装方法（在本次JVM进程中有效且只能通过反射调用）

public void setAccessible(boolean flag) throws SecurityException
class Person{
    private String name;
    private int age;
    public Person(){}
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 class Test2{
    public static void main(String[] args) throws Exception {
        //1.拿到PersonClass对象
        Class<?> cls = Person.class;
        //2.创建Person实例化对象
        Person per = (Person) cls.newInstance();
        //3.拿到name的Field对象
        Field field = cls.getDeclaredField("age");
        //动态设置封装
        field.setAccessible(true);
        field.set(per,18);
        System.out.println(field.get(per));
    }
}

3.ClassLoader类加载器

3.1认识ClassLoader

首先通过Class类观察如下方法：

public ClassLoader getClassLoader();

类加载器：通过一个类的全名称来获取此类的二进制字节流，实现操作的代码模块称为类加载器。

public class Test2{
    public static void main(String[] args) {
        Class<?> cls = Test2.class;
        System.out.println(cls.getClassLoader());
        //取得父类加载器
        System.out.println(cls.getClassLoader().getParent());
        System.out.println(cls.getClassLoader().getParent().getParent());
    }
}

JDK中内置的三大类加载器：

Bootstrap（启动类加载器）：

I.使用C++实现，是JVM的一部分，其他所有类加载器均使用Java实现。

II.负责将放于Java_HOME\lib目录下的能被JVM识别的类库加载到JVM中。

III.启动类加载器无法被Java程序直接引用。

ExtClassLoader（扩展类加载器）：

I.使用Java实现，并且可以被Java程序直接引用。

II.加载Java_Home\lib\ext目录下能被识别的类库。

APPClassLoader（应用程序类加载器）：

I.负责加载用户路径（classPath）上指定的类库。

II.如果应用程序中没有自定义类加载器，则此加载器就是Java程序中默认的类加载器。

3.2类加载器双亲委派模型-JDK1.2引入

        定义：JDK内置的三种类加载器与用户自定义类加载器之间的层次关系成为类加载器的双亲委派模型。要求除了顶层的父类加载器外，其余的类加载器都应有自己的父类加载器。

        执行流程：如果一个类加载器收到了类加载的请求，它首先不会自己尝试加载此类，而是把类加载请求委托给父类加载器完成，每一个层次类加载器均是如此。只有当父类加载器无法完成加载请求时（在自己搜索范围内没有找到此类），子类加载器才会尝试自己去加载。

        意义：双亲委派模型保证了Java程序稳定运行。Java中基础类一定由顶层BootStrap类加载器加载，因此，诸如Object等核心类在各种类加载器环境下都是同一个类。

 

 

gx1500291
关注
专栏目录
Java学习day058 反射和泛型（泛型Class类、使用Class<T>参数进行类型匹配、虚拟机中的泛型类型信息）
Zzehao的博客
04-16 1471
使用的教材是java核心技术卷1，我将跟着这本书的章节同时配合视频资源来进行学习基础java知识。 day058 反射和泛型（泛型Class类、使用Class参数进行类型匹配、虚拟机中的泛型类型信息） 反射允许你在运行时分析任意的对象。如果对象是泛型类的实例，关于泛型类型参数则得不到太多信息，因为它们会被擦除。下面了解一些利用反射可以获得泛型类的什么信息。 1.泛型Class类 现在，...
【JavaSE】反射
知识输出、记录学习
09-22 203
尚硅谷JavaSE笔记——反射。个人实践总结，知识记忆架构不一定适合所有人，建议先阅读文章目录
Java 在反射上使用泛型
nvd11的专栏
10-16 1510
Java 中 我们可以用类名.Calss or 对象名.getClass()去获得一个Class。而这个Class本身也是一个类，而且是1个泛型类。....所以在反射中， 我们也可以使用泛型的。这里只介绍两个常用的泛型类Class>
Java-反射
xhmico的博客
05-07 556
为什么要学习反射？从语言的设计角度来考虑，反射使 Java 具备动态性，我们可以让程序在运行期才确定执行的结果，在不修改源码的情况下来扩展功能或者是控制程序Java是一门面向对象的语言，封装是面向对象的一个特性，它允许抽象的类把自己的数据和方法只让可信的类或者对象进行操作，对不可信的进行信息隐藏（private修饰），而反射能够使我们去操作这些私有的变量和方法反射是Java的灵魂，没有反射，甚至Spring的那些框架也不复存在，学习反射是为了之后去读一些框架的底层源码更容易理解。
Java反射之Constructor、Method、Field使用及说明
不当初
01-16 2986
1 简介 在编程生活中，一般处理业务时不需要使用反射的内容，因为反射属于Java编程中的高级知识。但当我们需要迈向更高级的Java编程时，运行时类型信息是必须深刻理解的，在Spring MVC中，各种注解底层实现的方式就是使用了类型信息。 运行时类型信息（runtime type infomation）使得你可以在程序运行时发现和使用类型信息。它使得我们从只能在编译期执行面向类型的操作的禁锢中解脱...
黑马程序员--Java基础加强--16.利用反射操作泛型V【通过Constructor反射解析泛型构造方法】【通过Field反射解析泛型成员变量】【个人总结】
歆明正航的专栏
08-10 2248
利用反射操作泛型IV 通过Constructor反射解析泛型构造方法 通过Field反射解析泛型成员变量 ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 1.    通过Constructor反射解析泛型构造方法 1). 构造方法和普通方法关系 (1). 构造方法和普通方法的区别 [1]. 普通方法必须有返回值
JavaSE反射详解.ppt
06-08
JavaSE反射详解
javaSE 反射详解1
最新发布
09-24
javaSE 反射详解。
JavaSE 高级反射-JVM篇.xmind
09-12
JavaSE 高级反射-JVM篇
JavaSE反射技术
10-15
JavaSE反射技术是Java编程语言中的一个重要特性，它允许程序在运行时检查和操作类、接口、字段和方法等对象。这种动态类型的能力使得Java在处理未知类或接口时具有很大的灵活性，尤其在框架和库的开发中发挥着关键...
4Java反射与泛型——1反射——4调用构造方法（廖雪峰）
qq_24573381的博客
08-05 280
1newInstance Class.newInstance()只能调用public无参数构造方法 String s = (String) String.class.newInstance(); Integer n = (Integer) Integer.class.newInstance();//不能直接调用，因为Integer没有定义无参数的构造方法 2Constructor对象 如何调用带参数的构造方法呢？ 可以调用Constructor方法，Constructor对象包含一个构造方法的所
提炼Java Reflection
lsy
07-28 232
反射是Java语言中很重要的一个组成部分，所以就此话题讨论的资源可谓数之不尽，日常开发也会经常使用到关于反射的Reflection API。Java5.0 Tiger出现以后，更对反射API有了新的扩展，尽管讨论的话题很多，不过我还是觉得不够全面，尤其是对泛型这一块，所以就我所知，再花力气总结一番首先反射的入口是从Class开始的，所以如何获取Class就变得十分关键了。这里总结了几种方式：1.通...
18.Java 反射，Constructor＜T＞对象，泛型，类型通配符，可变参数，对象的序列化和反序列化
胡启行的博客
03-29 490
//获取Class对象 //方式一： Student stu = new Student(); Class<? extends Student> clazz1 = stu.getClass(); System.out.println(clazz1); //输出 class Student //方式二： Class<Student> clazz2 = Student.class; System.out.println(clazz2); //输出 class Student
getDeclaredConstructor() 与 getConstructor()方法
laomei
04-25 8567
getConstructor()返回指定参数类型public的构造器。 getDeclaredConstructor()返回指定参数类型的private和public构造器。对于getDeclaredConstructor方法获得的构造器需要先设置可访问，在实例化对象。public class Test { public Test() { System.out.printl
反射中getDeclaredConstructors和getConstructors两个方法的区别，然后setAccessible什么时候用，作用是什么？
走过路过不要错过
06-08 2415
1.getDeclaredConstructors和getConstructors的区别
反射（Constructor、Field、Method、类加载器）
sophia__yu的博客
12-01 371
一：什么是反射 在认识反射之前，首先回顾下什么是正向处理。如果我们需要实例化一个对象，首先需要导入这个类的包，在这个包中找这个类： package CODE.反射; import java.util.Date; public class Fan { public static void main(String[] args) { Date date =new Date(...
黑马程序员--03.反射--04【AccessibleObject类】【反射获取成员字段】
歆明正航的专栏
07-31 2153
反射----4       AccessibleObject类        反射获取成员字段 ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 1.    AccessibleObject类 1). AccessibleObject类 (可访问对象类) (1). 继承体系结构 Field、Const
JavaSE注解与反射详解
"这是一份关于JavaSE中注解和反射的文档，主要涵盖了注解的基本概念、内置注解的使用以及元注解的介绍。" 在Java编程中，注解（Annotation）是一种元数据，从JDK 5.0版本开始引入，用于向编译器、开发工具或者其他...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gx1500291

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值