注解和反射

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量86 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48638578/article/details/120336228
版权

文章目录

注解和反射

一、注解 Annotation
1.1、元注解
//Target表示我们的注解可以用在那些地方
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//Retention 表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)
//Documented 表示是否将我们的注解生成在JavaDoc中
@Documented
//Inherited 子类可以继承父类的注解
@Inherited
//@interface 定义注解
@interface MyAnnotation{
}
1.2、自定义注解
public class TestAnnotation {
    @MyAnnotation(name = "李四", value = 5)
    public void test() {
    }
}

//自定义注解

//Target表示我们的注解可以用在那些地方
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//Retention 表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)
//Documented 表示是否将我们的注解生成在JavaDoc中
@Documented
//Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
    //注解的参数 : 参数类型 + 参数名();
    String name();
    //可以给参数设置默认值
    int id() default 0;
    
    String[] schools() default {"北京大学","清华大学"};

    //只有一个参数时,一般将参数名设为value
    int value();
}
二、反射 Reflection

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法

对于每个类而言,JRE都为其保留一个不变的Class类型的对象(唯一的),一个Class对象包含了特定的

**注:**只要元素类型与维度一样,就是同一个Class

Class 类:

  1. Class本身也是一个类
  2. Class对象只能由系统建立对象 - --(我们只能获取)
  3. 一个加载的类在JVM中只会由一个Class实例
  4. 一个Class对象对应的是一个加载到JVM中的一个 .class 文件
  5. 每个类的实例都会记得自己是由哪个Class实例所生成
  6. 通过Class可以完整地得到一个类中的所有被加载的结构
  7. Class类是Reflection的根源,针对任何你想动态加载、运行的类、唯有先获得相应的Class对象
1.1: 只要元素类型与维度一样,就是同一个class
public static void main(String[] args) {

        int[] ints1 = new int[10];
        int[] ints2 = new int[20];
        System.out.println(ints1.getClass().hashCode());  //  1836019240
        System.out.println(ints2.getClass().hashCode());  //  1836019240

        ArrayList list1 = new ArrayList<>();
        ArrayList list2 = new ArrayList<>();
        System.out.println(list1.getClass().hashCode());  // 325040804
        System.out.println(list2.getClass().hashCode());  // 325040804

        int[][] ints = new int[10][10];
        int[] ints3 = new int[10];
        System.out.println(ints.getClass().hashCode());  // 1173230247
        System.out.println(ints3.getClass().hashCode()); // 1836019240  不同

        A a = new A();
        A a1 = new A(1);
        System.out.println(a.getClass().hashCode());     // 856419764
        System.out.println(a1.getClass().hashCode());    // 856419764
    }
}
class A{
    private int anInt;
    public A() {}
    public A(int anInt) {
        this.anInt = anInt;
    }}
1.2: 得到Class类的几种方式
public class ReflectionTest2 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一 : 通过对象获得
        Person stu = new Student();
        Class c1 = stu.getClass();
        System.out.println(c1.hashCode());

        //方式二 : 通过forname获得
        Class c2 = Class.forName("注解_反射.reflection.Student");
        System.out.println(c2.hashCode());

        //方式三 : 通过类名 .class 获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());

        //方式四 : 基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);   //int
    }
}

class Person{
}

class Student extends Person{  
}
1.3: 所有类型的class
        Class c1 = Object.class;         //类
        Class c2 = Comparable.class;     //接口
        Class c3 = String[].class;       //一维数组
        Class c4 = int[][].class;        //二维数组
        Class c5 = Override.class;       //注解
        Class c6 = ElementType.class;    //枚举
        Class c7 = Integer.class;        //基本数据类型
        Class c8 = void.class;           //void
        Class c9 = Class.class;          //class
1.4: 类加载–内存分析

​ jvm:

在这里插入图片描述

​ 堆:

​ 1.存放new的对象和数组

​ 2.可以被所有的线程共享,不会存放别的对象引用

方法区会在以后逐步移除，采用方法区会在以后逐步移除，采用native memory来实现方法区的规划，好像是因为方法区的回收比较困难，也因此导致过很多严重的bug来实现方法区的规划，好像是因为方法区的回收比较困难，也因此导致过很多严重的bug，常量池 jdk7后存于堆中，节约内存

​ 栈:

​ 1.存放基本变量类型（会包含这个基本类型的具体数值）

​ 2.引用对象的变量（会存放这个引用在堆里面的具体地址）

​ 方法区：

​ 1.可以被所有的线程共享

​ 2.包含了所有的class和static变量

1.5: 获取类的运行时结构
public class ReflectionTest4 {
    public static void main(String[] args) throws Exception {
        Class c1 = User.class;
        //获取类的名字
        System.out.println(c1.getName()); //获得包名+类名
        System.out.println(c1.getSimpleName()); //获得类名
        System.out.println("====================");

        //获得类的属性
        Field[] fields = c1.getFields();  //只能获得public修饰的属性
        System.out.println(Arrays.toString(fields));

        fields = c1.getDeclaredFields();  //获得全部属性
        System.out.println(Arrays.toString(fields));
        //获得指定属性
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
        System.out.println("====================");

        //获取类的方法
        Method[] methods = c1.getMethods();    //获取本类及父类所有public方法
        System.out.println(Arrays.toString(methods));
        methods = c1.getDeclaredMethods();     //获取本类所有方法
        System.out.println(Arrays.toString(methods));
        //获取指定方法  --有参数和无参数
        Method setAge = c1.getDeclaredMethod("setAge", int.class);
        System.out.println(setAge);
        Method getAge = c1.getDeclaredMethod("getAge",null); //null 可传可不传
        System.out.println(getAge);
        System.out.println("====================");

        //获取类的构造器
        Constructor[] constructors = c1.getConstructors();   //只能获取public的构造器
        System.out.println(Arrays.toString(constructors));
        constructors = c1.getDeclaredConstructors();         //获取本类的所有构造器
        System.out.println(Arrays.toString(constructors));
        //获取指定的构造器
        Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);
        System.out.println(constructor);
    }
}

class User{
    public int size;
    private int age;
    private String name;

    public User() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
1.6：动态创建对象执行方法
 public static void main(String[] args) throws Exception {
        Class c1 = User.class;

        //调用newInstance 构造对象.本质是调用了类的无参构造
        User user = (User) c1.newInstance();
        System.out.println(user);

        //当类中没有无参构造时
        Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);
        user = (User) constructor.newInstance(1,"张三");
        System.out.println(user);

        //调用类中方法
        user.setAge(10);
        System.out.println(user);
        //使用反射掉用类中方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke : 激活的意思
        setName.invoke(user, "李四");
        System.out.println(user);

        //通过反射操作属性
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性, 我们需要    打开访问权限   暴力反射
        name.setAccessible(true);
        name.set(user,"王五");
        System.out.println(user.getName());
        
        Method eat = c1.getDeclaredMethod("eat");
        eat.setAccessible(true);
        eat.invoke(user);
    }
1.7：反射获取注解信息
 public static void main(String[] args) throws Exception {
        Class c1 = TableUser.class;
        //获取注解.获得了类上的注解  
        Annotation[] annotations = c1.getAnnotations();
        System.out.println(Arrays.toString(annotations));

        //获得类中字段上的注解
        Field id = c1.getDeclaredField("id");
        Annotation[] annotations1 = id.getAnnotations();
        System.out.println(Arrays.toString(annotations1));
        //获取指定注解中的值
        FieldAnnotation fieldAnnotation = id.getAnnotation(FieldAnnotation.class);
        System.out.println(fieldAnnotation.columnName());
        System.out.println(fieldAnnotation.type());

        //获取指定注解
        Annotation annotation = c1.getAnnotation(TableAnnotation.class);
        System.out.println(annotation);
    }
}

@TableAnnotation("db_user")
@Data
class TableUser{
    @FieldAnnotation(columnName = "id",type = "int")
    private int id;
    @FieldAnnotation(columnName = "name",type = "varchar")
    private String name;
}

//Target表示我们的注解可以用在那些地方
@Target(value = ElementType.TYPE)
//Retention 表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)
@interface TableAnnotation{
    String value();
}

@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
@interface FieldAnnotation{
    String columnName();
    String type();
}
牛娃_
关注
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1256
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
注解和反射总结
Cristo_Li的博客
04-22 680
文章目录一、注解二、使用步骤1.引入库2.读入数据总结 一、注解 Annotation：@+注释名 不是程序本身，但可以对程序作出解释 可以被其他程序（比如：编译器等）读取 相当于添加了额外的辅助信息，可以通过反射机制编程实现对被注解标注的元数据的访问 举例：@SuppressWarning(“all”)：抑制编译时一些无关紧要的警告信息 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib
自定义注解和反射
qq_41512902的博客
08-06 1219
自定义注解和反射
Java：注解和反射
希望有点用
05-21 2495
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
注解和反射学习总结
weixin_43659561的博客
02-22 403
注解和反射学习总结注解注解的基本概念内置注解元注解 注解 注解的基本概念 注解（Annotation）是从JDK5.0就是引入的。 Annotation的作用：不是程序本身，可以对程序作出解释。同时可以被其他程序（比如编译器）读取。 Annotation的格式：注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarings(value=“unchecked”)。 Annotation的在哪里使用：可以附加在package，class，method，field等上面，相当于给
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 962
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
Java进阶——注解和反射
万里顾一程的博客
03-26 6222
文章目录Java基础——注解和反射1、注解1.1、什么是注解(Annotation)1.2、内置注解1.3、自定义注解和元注解(meta-annotation)2、反射1、反射和反射机制2、CLass类3、哪些类型可以有Class对象4、类加载理解5、类加载器6、通过反射动态的创建对象7、反射操作注解 Java基础——注解和反射 1、注解 1.1、什么是注解(Annotation) 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
注解和反射(狂神) 笔记
weixin_43905212的博客
12-14 1409
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
从springboot中的注解再次理解注解和反射
qq_41980102的博客
04-08 1501
从springboot注解再次理解注解和反射 为了看懂源码的注解和反射 1、自述 ​ 在日常的开发中，大家可能已经留意到注解的声影随处可见，特别是在看Springboot源码的时候，自动装配里面运用大量的注解，起初我看源码也是云里雾里的，现在我总结一下我浅薄的见解和理解吧。 2、注解的基础用法 2.1什么是注解？ 对于很多初次接触的开发者来说应该都有这个疑问？ Annontation 是Ja...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
06-27
根据提供的文件信息，我们可以梳理出以下知识点： ...以上知识点详细阐述了文档中提到的方法和技术原理，为理解和应用Java注解和反射机制在Excel文件读写操作中的实际应用提供了理论基础和技术指导。
Java使用注解和反射简化编程的方法示例
08-25
例如，在调用大量方法时，可以使用反射和注解简化编程。 下面是一个使用注解和反射简化编程的实例。首先，定义一个注解testAnnoation10： ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target...
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
java基础之注解和反射
08-05
java基础之注解和反射
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 608
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 251
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 565
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 546
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值