day43-反射02

2023年6月15日下午6:32 • Java • 阅读 68

Java反射02

2.Class类

2.1基本介绍

Class类也是类，因此也继承Object类
Class类对象不是new出来的，而是系统创建的
对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class对象可以得到一个类的完整结构（通过一系列API）
Class对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码，变量名，方法名，访问权限等）

当我们加载完类之后，除了会在堆里生成一个Class类对象，还会在方法区生成一个类的字节码二进制数据（元数据）

例子：

package li.reflection.class_;

import li.reflection.Cat;

//对Class类的特点的梳理
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {

        //1.Class类对象不是new出来的，而是系统创建的
        //1.1.传统的 new对象
        /**通过ClassLoader类中的loadClass方法：
         *  public Class loadClass(String name) throws ClassNotFoundException {
         *         return loadClass(name, false);
         *  }
         */
         //Cat cat = new Cat();

        //1.2反射的方式
        /**在这里debug，需要先将上面的Cat cat = new Cat();注释掉，因为同一个类只加载一次，否则看不到loadClass方法
         * （这里也验证了：3.对于某个类的Class类对象，在内存中只有一份，因为类只加载一次）
         * 仍然是通过 ClassLoader类的loadClass方法加载 Cat类的 Class对象
         *  public Class loadClass(String name) throws ClassNotFoundException {
         *         return loadClass(name, false);
         *     }
         */
        Class cls1 = Class.forName("li.reflection.Cat");

        //2.对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
        Class cls2 = Class.forName("li.reflection.Cat");
        //这里输出的hashCode是相同的，说明cls1和cls2是同一个Class类对象
        System.out.println(cls1.hashCode());//1554874502
        System.out.println(cls2.hashCode());//1554874502
    }
}

Class类对象不是new出来的，而是系统创建的：

在 Cat cat = new Cat();处打上断点，点击force step into，可以看到

注释 Cat cat = new Cat();，在 Class cls1 = Class.forName("li.reflection.Cat");处打上断点，可以看到仍然是通过 ClassLoader类加载 Cat类的 Class对象

2.2Class类常用方法

public static Class forName(String className)//传入完整的"包.类"名称实例化Class对象
public Constructor[] getContructors() //得到一个类的全部的构造方法
public Field[] getDeclaredFields()//得到本类中单独定义的全部属性
public Field[] getFields()//得到本类继承而来的全部属性
public Method[] getMethods()//得到一个类的全部方法
public Method getMethod(String name,Class..parameterType)//返回一个Method对象，并设置一个方法中的所有参数类型
public Class[] getInterfaces() //得到一个类中锁实现的全部接口
public String getName() //得到一个类完整的"包.类"名称
public Package getPackage() //得到一个类的包

public Class getSuperclass() //得到一个类的父类
public Object newInstance() //根据Class定义的类实例化对象
public Class getComponentType() //返回表示数组类型的Class
public boolean isArray() //判断此class是否是一个数组

应用实例

Car:

package li.reflection;

public class Car {
    public String brand = "宝马";
    public int price = 500000;
    public String color ="白色";

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

Class02:

package li.reflection.class_;

import li.reflection.Car;

import java.lang.reflect.Field;

//演示Class类的常用方法
public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String classAllPath = "li.reflection.Car";

        //1.获取到 Car类 对应的 Class对象
        //表示不确定的Java类型
        Class cls = Class.forName(classAllPath);

        //2.输出cls
        System.out.println(cls);//将会显示cls对象是哪个类的Class对象  class li.reflection.Car
        System.out.println(cls.getClass());//输出cls的运行类型 class java.lang.Class

        //3.得到包名
        System.out.println(cls.getPackage().getName());//li.reflection :Class对象对应的类是在哪个包下面

        //4.得到全类的名称
        System.out.println(cls.getName());//li.reflection.Car

        //5.通过cls创建一个对象实例
        Car car = (Car)cls.newInstance();
        System.out.println(car);//调用car.toString()

        //6.通过反射获得属性 如：brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马

        //7.通过反射给属性设置值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car));//奔驰

        //8.遍历得到所有的属性（字段）
        Field[] fields = cls.getFields();
        for (Field f:fields) {
            System.out.println(f.getName());//依次输出各个属性字段的名称
        }
    }
}

2.3获取Class类对象的各种方式

前提：已经知道一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException 实例： Class cls1 = Class.forName("java.lang.Cat"); 应用场景：多用于配置文件，读取类全路径，加载类
前提：若已知具体的类，通过类.class 获取，该方式最为安全可靠，程序性能最高实例： Class cls2 = Cat.class; 应用场景：多用于参数传递，比如通过反射得到对应构造器对象
前提：已某个类的实例，调用该实例的getClass()方法获取Class对象实例： Class cls3 = 对象.getClass();//运行类型 应用场景：通过创建好的对象，获取Class对象
其他方式 ClassLoader cl = 对象.getClass().getClassLoad(); Class cls4 = cl.loadClass("类的全类名");
基本数据类型 byte,short,int,long,double,float,boolean.char, 按如下方式得到Class类对象 Class cls = 基本数据类型.class
基本数据类型对应的包装类，可以通过 .TYPE得到Class类对象 Class cls = 包装类.TYPE

例子：

package li.reflection.class_;

import li.reflection.Car;

//演示得到Class对象的各种方式
public class getClass_ {
    public static void main(String[] args) throws ClassNotFoundException {

        //1.Class.forName
        String classAllPath = "li.reflection.Car";//这里一般是通过配置文件获取全路径
        Class cls1 = Class.forName(classAllPath);
        System.out.println(cls1);//class li.reflection.Car

        //2.类名.class ,多用于参数传递
        Class cls2 = Car.class;
        System.out.println(Car.class);//class li.reflection.Car

        //3.对象.getClass() ,应用场景，有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);//class li.reflection.Car

        //4.通过类加载器(4种)来获取到类的 Class对象
        //(1)先得到car对象的类加载器（每个对象都有一个类加载器）
        ClassLoader classLoader = car.getClass().getClassLoader();
        //（2）通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);//class li.reflection.Car

        //cls1,cls2,cls3,cls4其实是同一个Class对象
        System.out.println(cls1.hashCode());//1554874502
        System.out.println(cls2.hashCode());//1554874502
        System.out.println(cls3.hashCode());//1554874502
        System.out.println(cls4.hashCode());//1554874502

        //5.基本数据类型按如下方式得到Class类对象
        Class integerClass = int.class;
        Class characterClass = char.class;
        Class booleanClass = boolean.class;
        System.out.println(integerClass);//int
        System.out.println(characterClass);//char
        System.out.println(booleanClass);//boolean

        //6.基本数据类型对应的8种包装类，可以通过 .TYPE得到Class类对象
        Class type1 = Integer.TYPE;
        Class type2 = Character.TYPE;
        System.out.println(type1);

        System.out.println(integerClass.hashCode());//1846274136
        System.out.println(type1.hashCode());//1846274136

    }
}

2.4哪些类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类
interface：接口
数组
enum：枚举
annotation：注解
基本数据类型
void

例子：

package li.reflection.class_;

import java.io.Serializable;

//演示哪些类有Class对象
public class allTypeClass {
    public static void main(String[] args) {

        Class cls1 = String.class;//外部类
        Class cls2 = Serializable.class;//接口
        Class cls3 = Integer[].class;//数组
        Class cls4 = float[][].class;//二维数组
        Class cls5 = Deprecated.class;//注解
        //Thread类中的枚举State--用来表示线程状态
        Class cls6 = Thread.State.class;//枚举
        Class cls7 = long.class;//基本数据类型
        Class cls8 = void.class;//void类型
        Class cls9 = Class.class;//Class类也有

        System.out.println(cls1);//class java.lang.String
        System.out.println(cls2);//interface java.io.Serializable
        System.out.println(cls3);//class [Ljava.lang.Integer;
        System.out.println(cls4);//class [[F
        System.out.println(cls5);//interface java.lang.Deprecated
        System.out.println(cls6);//class java.lang.Thread$State
        System.out.println(cls7);//long
        System.out.println(cls8);//void
        System.out.println(cls9);//class java.lang.Class
    }
}

2.5类加载

基本说明：反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载
静态加载：编译时加载相关的类，如果没有则报错，依赖性太强

静态加载的类，即使没有用到也会加载，并且进行语法的校验
动态加载：运行时加载相关的类，如果运行时不用该类，即使不存在该类，也不会报错，降低了依赖性
类加载的时机：
当创建对象时（new）//静态加载
当子类被加载时 //静态加载
调用类中的静态成员时 //静态加载
通过反射 //动态加载

例子：静态加载和动态加载

import java.lang.reflect.*;
import java.util.*;

public class classLoad_ {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入key");
        String key = scanner.next();
        switch (key) {
            case "1":
                Dog dog = new Dog();//静态加载，依赖性很强
                dog.cry();
                break;
            case "2":
                //反射 -->动态加载
                Class cls = Class.forName("Person"); //加载Person[动态加载]
                Object o = cls.newInstance();
                Method m = cls.getMethod("hi");
                m.invoke(o);
                System.out.println("ok");
                break;
            default:
                System.out.println("do nothing...");
        }
    }
}

//因为new Dog()是静态加载，因此必须编写Dog
//Person类是动态加载，所以即使没有编写Person类也不会报错，只有当动态加载该类时，（有问题）才会报错
class Dog{
    public void cry(){
        System.out.println("小狗在哭泣..");
    }
}

在没有编写Dog类时，即使在switch选择中，不一定会运行到new dog对象的case1，但是程序仍然报错了，因为静态加载的类，即使没有用到，也会加载，并且进行语法的校验

在编写了Dog类对象后，可以看到编译通过：

运行程序：可以看到，即使没有编写Person类，但是运行时没有用到，就不会报错

使用到Person类，报错：（运行时加载）

2.6类的加载过程

类加载过程图

类加载各阶段完成的任务
加载阶段：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
连接阶段：将类的二进制数据合并到jre中
初始化阶段：JVM负责对类进行初始化，这里主要是指静态成员

2.6.1加载阶段

JVM 在该阶段的主要目的是，将字节码从不同的数据源（可能是class文件，也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

2.6.2连接阶段-验证

目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
包括：文件格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证

可以考虑使用 -Xverify：none 参数关闭大部分的类验证措施，缩短虚拟机类加载的时间

2.6.3连接阶段-准备

JVM会在该阶段对静态变量，分配内存并默认初始化（对应的数据类型的默认初始值，如0，0L，null，false等）。这些变量所使用的内存都将在方法区中进行分配

例如：

package li.reflection.classload_;

//我们说明一个类加载的链接阶段-准备
public class ClassLoad02 {
    public static void main(String[] args) {

    }
}

class A {
    //属性-成员变量-字段
    //一个类加载的链接阶段中的准备阶段 属性是如何处理的
    //1. n1 是实例变量，不是静态变量，因此在准备阶段，是不会分配内存的
    //2. n2 是静态变量，分配内存 n2，且默认初始化为 0，而不是20
    //3. n3 是static final，是常量，它和静态变量不一样，因为一旦赋值就不变，n3 = 30
    public int n1 = 10;
    public static int n2 = 20;
    public static final int n3 = 30;
}

2.6.4连接阶段-解析

虚拟机将常量池内的符号引用替换为直接应用的过程

个人理解 java虚拟机中的符号引用和直接引用_maerdym的博客-CSDN博客

2.6.5初始化阶段

到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行 <clinit>()</clinit>方法的过程
<clinit>()</clinit>方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有 静态变量 的赋值动作和 静态代码块中的语句，并进行合并。–>例子1
虚拟机会保证一个类的 <clinit>()</clinit>方法在多线程环境中被正确地加锁、同步，如果多线程同时去初始化一个类，那么只会有一个线程去执行这个类的 <clinit>()</clinit>方法，其他线程都需要阻塞等待，直到活动线程执行 <clinit>()</clinit>方法完毕。

例子1：演示类加载的初始化阶段

package li.reflection.classload_;

//演示类加载的初始化阶段
public class ClassLoad03 {
    public static void main(String[] args) {
        //分析：
        /**
         * 1.加载B类，并生成 B的Class对象
         * 2.链接 ：将num默认初始化为 0
         * 3.初始化阶段：
         *    3.1依次 自动收集类中的 所有静态变量的赋值动作 和 静态代码块中的语句,并合并
         *      收集：
         *      clinit(){
         *          System.out.println("B的静态代码块被执行");
         *          num = 300;
         *          num = 100;
         *      }
         *      合并：num =100;
         */

        //直接使用类的静态属性也会导致类的加载
        System.out.println(B.num);//100

    }
}

class B {
    static {
        System.out.println("B的静态代码块被执行");
        num = 300;
    }

    static int num = 100;

    public B() {
        System.out.println("B的构造器被执行");
    }
}

例子2：

在例子1中的程序里创建一个B类对象，打上断点，debug源码：

可以看到在底层中，使用了对象锁 synchronized (getClassLoadingLock(name)) :

也就是说，加载类的时候，是有类的同步控制机制。

正因为有这个机制，才能保证某个类在内存中，只有一份Class对象。

Original: https://www.cnblogs.com/liyuelian/p/16739387.html
Author: 一刀一个小西瓜
Title: day43-反射02

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/615609/

转载文章受原作者版权保护。转载请注明原作者出处！

Java

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

一本软考教材，治好了我多年的低血压

事情是这样的，最近想要考一个高级软件资格证书，于是二话不说买了”信息系统项目管理师”相关资料就开始学起来了。教材一到手，刚翻开第一页读了个序言，曾经熟悉的味…

Java 2023年6月15日
0051
spring整合mybatis

<dependencies> <dependency> <groupid>mysql</groupid> <artifacti…

Java 2023年6月15日
0085
Feign Interceptor 拦截器实现全局请求参数

在第三方API对接中通常所有接口都需要在Header或Param放置固定参数（Token、开发者Key等），因为是SpringCloud开发，一般HTTP工具采用Feign。如果选…

Java 2023年6月5日
0075
数据库篇：mysql日志类型之 redo、undo、binlog

前言可以说mysql的多数特性都是围绕日志文件实现，而其中最重要的有以下三种 redo 日志 undo 日志 binlog 日志关注公众号，一起交流；微信搜一搜: 潜行前行 1…

Java 2023年6月5日
0073
Skywalking-07：OAL原理——解释器实现

OAL 解释器实现 OAL 解释器是基于 Antlr4 实现的，我们先来了解下 Antlr4 Antlr4 基本介绍 Antlr4 使用案例参考Antlr4的使用简介这篇文章，我…

Java 2023年6月5日
0085
【IoT】thingsboard3.3.3测试，使用node-mqtt发送消息

thingsboard.yml端口1883 服务器防火墙开启1883端口 mqtt消息发送，代码来自互联网：脚本地址 https://blog.csdn.net/ieflex/ar…

Java 2023年5月29日
0081
Java如何对HashMap按值进行排序–非String int 类型时

比如：Float 可以通过相减取整返回，如下方： Java如何对HashMap按值进行排序_上善若水，水善利万物而不争。-CSDN博客https://blog.csdn.net/…

Java 2023年5月29日
0069
【笔记】并查集—无向图处理代码模板及类型题

并查集要处理的两个问题查询图中两个顶点是否在同一个集合之中。将两个不相交的集合进行合并。设计并查集的两种思想基于id 给每个顶点分配一个唯一的标识，称为 id id 不同则…

Java 2023年6月7日
0081
MyBatis(二)-CURD (ResultMap 一对一，一对多)

1、insert 标签 1.1 获取SqlSessionFactory 对象的通用方法方便后面分测试； //获取SqlSessionFactory 对象的通用方法 public …

Java 2023年6月15日
0061
java多线程系列(1)

1，为什么需要线程? 作用：提升cpu的利用率，如，早期的dos系统，执行2个命令时( command 1, command 2 )，如果command1【假如是磁盘遍历文件的IO…

Java 2023年5月29日
0097
Fizz企业级微服务API网关进阶系列教程-服务编排处理列表数据(下)-字段重命名&字段移除

概述服务编排是Fizz网关提供的一个强大的功能，能够基于现有的业务微服务通过在线配置的方式快速的生成一个聚合接口，减少中间层胶水代码以及降低编码投入。在服务编排中支持使用函数…

Java 2023年6月9日
0079
Spring MVC的主要组件和工作流程

Spring MVC的主要组件（1）前端控制器 DispatcherServlet（不需要程序员开发）作用：接收请求、响应结果，相当于转发器，有了DispatcherServl…

Java 2023年6月13日
0066
参加了个算法比赛，真是一言难尽啊

hello大家好呀，我是小楼。上周参加了一个区的程序员技能比赛的初赛，其实就是算法比赛，虽然最后结果是过了初赛，但过程真是一言难尽啊。这次的算法比赛和ACM非常类似，虽然我大学…

Java 2023年6月6日
0089
SpringBoot集成thymeleaf模板

1.在pom文件添加： org.springframework.boot spring-boot-starter-thymeleaf2.在html页面的头部添加 3.在java C…

Java 2023年6月14日
0063
Java基础知识点整理（2021年最新版）

看了网上很多关于Java基础知识点整理的文章，但是感觉都不是很好，要么不全面，要么不准确，要么排版太乱了，所以今天整理了一份Java基础知识点整理（2021年最新版），希望对大家有…

Java 2023年5月29日
0056
Linux命令拾遗-常用的辅助开发类命令

原创：打码日记（微信公众号ID：codelogs），欢迎分享，转载请保留出处。简介之前介绍了大量的命令，有基础操作相关的，也有问题诊断相关的，但Linux中还有一类命令，被时常…

Java 2023年6月7日
0089

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31