注解和反射

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量73 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37516650/article/details/116211065
版权
本文详细介绍了Java注解（Annotation）的概念、用途、元注解及其作用，以及如何使用反射机制（Reflection）访问和操作类的结构。涵盖了自定义注解、内置注解如@Override和SuppressWarnings，以及如何通过反射动态创建对象和操作注解。
摘要由CSDN通过智能技术生成

注解和反射

  1. 注解 Annotation ，为程序提供的可读性信息（被注解的部分，让程序知道它是干干什么用的）
Annotation的作用：对程序作出解释，可以被其他程序认识读取；
Annotation的格式：注释以 @注释名称 形式在代码中存在，还可以添加一些参数值，例如：@SuppressWarnings(value="unchecked")
Annotation在哪里使用：可以附加在 package、class、method、field 等上面，相当于给他们添加了额外的辅助信息，我们通过反射机制编程实现对这些元数据的访问。

  1. 内置注解

    @Override:此注解只适用于修辞方法，表示一个方法声明打算重写一个超类中的另一个方法声明；

    @SuppressWarnings：用来抑制编译时的警告信息，添加后置参数例如：(“unchecked”)

    @SuppressWarnings("all")//将警告抹平注解，不显示
public class test1 extends Object{
    @Override//重写方法注解
    public String toString() {
        return super.toString();
    }
    public static void test(){
        String testStr = "1";
    }
}
  1. 元注解

  • 作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation 类型作说明。

    @Target ：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）；

    //测试元注解
@MyAnnotation1 //注释只能用在类上，所有会报错
@MyAnnotation2 //可用
public class Test2 {
    @MyAnnotation1//可用
    @MyAnnotation2//可用
    public void test(){
        System.out.println("ok");
    }
}
//定义一个注解
@Target(value = ElementType.METHOD)//注解说明，这个接口只在方法上可用
@interface  MyAnnotation1{
}
@Target(value = {ElementType.TYPE, ElementType.METHOD})//注解说明，这个接口可以用在类和方法上
@interface MyAnnotation2{
}

    @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期 RUNTIME；

    @Document：说明该注解将被包含在javadoc中；

    @Inherited：说明子类可以继承父类中的该注解；

    //测试元注解
//@MyAnnotation1 //注释只能用在类上，所有会报错
@MyAnnotation2 //可用
public class Test2 {
    @MyAnnotation1//可用
    @MyAnnotation2//可用
    public void test(){
        System.out.println("ok");
    }
}
//定义一个注解
//注解说明，这个接口只在方法上可用
@Target(value = ElementType.METHOD)
@interface  MyAnnotation1{
}
//注解说明，这个接口可以用在类和方法上
@Target(value = {ElementType.TYPE, ElementType.METHOD})
//Retention 表示我们的注解在什么地方有效 RUNTIME > Class > Sources
@Retention(value = RetentionPolicy.RUNTIME)
//表示是否将我们的注解生成在JavaDoc中
@Documented
//表示子类可以继承父类的注解
@Inherited
@interface MyAnnotation2{
}
  1. 自定义注解：使用@interface自定义注解时，自动继承了Annotation接口
  • 声明格式：public @interface 注解名 { 定义内容}；
  • 定义内容中的每一个方法，实际上是声明了一个配置参数；
  • 方法的名称，就是参数的名称；
  • 返回值类型，就是参数的类型（返回值只能是基本类型Class、String、enum）；
  • 可以通过default 来声明参数的默认值；
  • 如果只有一个参数成员，最好使用value作为参数名；
  • 注解元素必须要有值，我们定义注解元素时，经常使用空字符串、0 作为默认值；
//自定义注解
public class Test3 {
    //注解可以显示赋值，如果没有显示，那么必须设置默认值
    @MyAnnotation3(name="小韩",sex ="男",eye=2)//其他参数因为有默认值，可以省略
    public void test1(){}
    @MyAnnotation4("爱你")// 因为只有一个注解，参数名为value，可以省略，不为value则不能省略
    public void test2(){}
}
//自定义注解3 （多个注解参数）
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    //注解的参数 ：返回值类型（参数类型）+ 参数名称+（）
    //通过default 可以设置默认值
    String name() default "";
    int age() default 0;
    String sex();
    int eye();
    String[] address() default {"北京","上海"};
}
//自定义注解4 （单个注解参数）只有一个注解参数时，将参数名使用value
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation4{
    String value();
}
  1. 反射机制 Reflection（反射）

  • Java反射机制：Java不是动态语言，但是被称为“准动态语言”，既Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性，让编程的时候更加灵活。

    val x = "123";
eval(x);  //eval函数可以执行某些参数。

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

    Class c = Class.forName("java.lang.String");

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

  1. 获得反射的对象
  • Java反射机制提供的功能：
    • 在运行时判断任意一个对象所属哪个类、类中所具有的成员变量和方法、调用任意一个对象成员变量和方法；构造任意一个类的对象；获取泛型信息；处理注解；生成动态代理。
    • 优点：实现动态创建对象和编译，体现出很大的灵活性
    • 缺点：性能有影响，反射是一种解释操作，我们告诉Jvm，它去给做，这种操作比正常new缓慢。
  1. 获得Class对象的几种方式
//测试Class类的创建方式
public class TestRefelction {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是：" + person.name);
        //方式一:
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        //方式二:
        Class c2 = Class.forName("com.han.study.refelction.Student");
        System.out.println(c2.hashCode());
        //方式三:
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        //方式四:
        Class c4 = c1.getSuperclass();
        System.out.println(c4);
        //特别的，内置类型包装类 Type属性
        Class type = Integer.TYPE;
        System.out.println(type);

    }
}
class Person{
    public String name;
    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }
}
class Student extends Person{
    public Student() {
        this.name = "学生";
    }
}

  1. 哪些类型可以有Class对象

    class：外部类，成员（内部类，静态内部类），局部内部类，匿名内部类。

    interface：接口

    []：数组

    enum：枚举

    annotation：注解@interface

    primitive type：基本数据类型

    void

  1. Java内存分析。类加载
public class TestRefelction01 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
        /*
         1.加载代码到内存，产生一个Class对象
         2.将各项代码链接，链接完成后给m赋初始化值 m=0
         3.初始化静态代码(static常量顺序加载)
            <clinit> {
                m = 100;
                System.out.println("静态代码块初始化");
                m = 300;
            }
         */
    }
}
class A{
    static int m = 100;
    static {
        System.out.println("静态代码块初始化");
        m = 300;
    }
    public A(){
        System.out.println("构造器初始化");
    }
}
//JVM加载过程（服务启动）
1.加载TestRefelction01类（方法区，指向到堆）
    静态变量，静态方法，常量，业务代码
2.加载 A 类（方法区，指向到堆）
    静态变量，静态方法，常量，业务代码

当执行Main方法时，在堆中new A() 对象。获取m=300的值，传递回栈中。
  1. 类何时进行初始化

  • 类的主动引用（一定会发生的初始化）

    当虚拟机启动，先初始化主方法所在的类；

    new 一个类的对象；

    调用类的静态成员（除了final 常量）和静态方法；

    使用reflect包的方法对类进行反射调用；

    初始化一个类，如果其父类没有被初始化，则先初始化它的父类；

  • 类的被动引用（不会发生类的初始化）

    当访问一个静态域时，只有真正声明这个域的类才能被初始化。如：当通过子类引用父类的引用父类的静态变量，不会导致子类初始化；

    通过数组定义类引用，不会触发此类的初始化；

    引用常量不会触发此类的初始化（常量在连接阶段就存入调用类的常量池中了）

  1. 获取类的运行结构（了解）
User user = new User();
Class c1 = user.Class();//反射获取User的各种结构
//获取类的属性 （两种：全部或者 只有public

//获取类中的方法（两种：全部或者 只有public

//获取构造器
  1. 反射的方式动态创建Class对象
//动态的创建对象，通过反射
public class Test06 {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        //获取Class对象
        Class c1 = person.getClass();
        //构造一个对象
        person = (Person)c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke 激活的意思
        //（对象，“方法的值”）
        setName.invoke(person, "zhangopw");
        System.out.println(person.getName());

        //通过反射获取操作属性
        Person person1 = (Person)c1.newInstance();
        Field age = c1.getDeclaredField("age");
        //不能直接操作私有属性，需要设置不检测
        age.setAccessible(true);
        age.set(person1,23);
        System.out.println(person1.getAge());
    }
}
  1. 练习反射操作注解
//练习反射操作注解
public class Test004 {
    public static void main(String[] args) throws Exception{
        Class c1 = Class.forName("com.han.study.Student4");
        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获取注解的value值
        TableHan annotation = (TableHan)c1.getAnnotation(TableHan.class);
        System.out.println(annotation.value());
        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        FieldHan annotation1 = name.getAnnotation(FieldHan.class);
        System.out.println(annotation1.col());
        System.out.println(annotation1.type());
        System.out.println(annotation1.len());

    }
}
//创建实体类
@TableHan("Db_student")
class Student4 {
    @FieldHan(col = "db_id", type = "int", len = 64)
    private int id;
    @FieldHan(col = "db_age", type = "int", len = 10)
    private int age;
    @FieldHan(col = "db_name", type = "varchar", len = 128)
    private String name;
    public Student4() {
    }
    public Student4(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student4{" + "id=" + id + ", age=" + age + ", name='" + name + '\'' + '}';
    }
}
//类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableHan{
    String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldHan{
    String col();
    String type();
    int len();
}
m0_37516650
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1201
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2375
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 932
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
Java进阶——注解和反射
万里顾一程的博客
03-26 6018
文章目录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 1365
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
08-05
java基础之注解和反射
注解和反射机制的学习笔记
03-05
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个强大的工具，它们极大地扩展了代码的灵活性和动态性。这篇学习笔记将深入探讨这两个主题，帮助开发者更好地理解和运用它们。 首先，我们来了解注解...
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
Java使用注解和反射简化编程的方法示例
08-25
例如，在调用大量方法时，可以使用反射和注解简化编程。 下面是一个使用注解和反射简化编程的实例。首先，定义一个注解testAnnoation10： ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target...
JAVA进阶补充
2301_80150315的博客
08-15 750
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 537
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 889
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 555
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 323
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 614
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 958
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 723
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值