注解与反射

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量78 收藏
点赞数 1
文章标签： java spring restful
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pxx1970/article/details/120290287
版权
本文详细讲解了Java中的注解 Annotation 的概念、内置注解的使用，自定义注解的创建，以及反射Reflection的原理、操作类、字段、方法和构造器等。重点介绍了如何动态创建对象和获取注解信息，适合开发者进一步掌握Java高级特性。
摘要由CSDN通过智能技术生成

注解与反射

1.注解Annotation

1.1什么是注解

在这里插入图片描述

2.内置注解

package com.Annotation;
public class Test01 extends Object{
    @Override  //重写的注解
    public String toString() {
        return super.toString();
    }
    //Deprecated 不推荐程序员使用，但是可以使用，或者存在更好的方式
    @Deprecated
    public static void test(){
        System.out.println("Deprecated");
    }
    @SuppressWarnings("all")//用来消除警告
    public void test2(){
        
    }
    public static void main(String[] args) {
        test();
    }  
}

3.自定义注解，元注解

1.元注解

在这里插入图片描述

package com.Annotation;

import java.lang.annotation.*;

 //测试元注解
@MyAnnotation
public class Test02 {
     @MyAnnotation
     public void test(){
        
    }
}

//@Target  表示我们的注解可以用在哪些地方
@Target(value = {ElementType.TYPE,ElementType.ANNOTATION_TYPE,ElementType.METHOD})

//@Retention  表示我们的注解在什么地方有效
@Retention(value = RetentionPolicy.RUNTIME)

//@Documented 表示是否将我们的注解生成在javadoc中
@Documented

//@Inherited 子类可以继承父类
@Inherited

//定义一个注解
@MyAnnotation 
@interface MyAnnotation{
    
}
2.自定义注解

在这里插入图片描述

package com.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//自定义注解
public class Test03 {
    //注解可以显示赋值，如果没有默认值，我们必须给注解赋值
    @MyAnnotation2(age=18)
    public void test(){}
    
    //只有注解默认参数名为value时，才可以省略
    @MyAnnotation3( "胡歌")
    public void test2(){}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)

@interface MyAnnotation2{
    //注解的参数:参数类型+参数名（）;
    String name() default "";
    int age() ;
    int id() default -1;//如果默认值为-1，代表不存在，   indexOf，如果找不到返回-1.
    String[] schools() default {"清华大学","北京大学"};
}

@Target({ElementType.TYPE,ElementType.METHOD})           
@Retention(RetentionPolicy.RUNTIME)                      
@interface MyAnnotation3{
      String value();
}

2.反射Reflection

在这里插入图片描述

  • 优点：可以实现动态创建对象和编译，体验出很大的灵活性

  • 缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉jvm，我们希望做什么并且它满足我们的要求，这类操作总是慢于直接执行相同的操作。

    2.1获得class类的实例

    package com.Annotation.Reflection;

public class Test02 {
    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());
        //方式二：format获得
        Class c2 = Class.forName("com.Annotation.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);
        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}
class Person{
   public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Student extends Person{
    public Student(){
        this.name="学生";
    }
}
class Teacher extends Person{
    public Teacher() {
        this.name="老师";
    }
}

2.2哪些类型可以有Class对象？

  1. class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类。
  2. interface：接口
  3. []:数组
  4. enum：枚举
  5. annotation：注解@interface
  6. primitive type：基本数据类型
  7. void
		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

请添加图片描述

在这里插入图片描述

package com.Annotation.Reflection;
/**
 *1.加载到内存，会产生一个类对应class对象
 * 2.链接，链接结束后m=0；
 * 3.初始化
 *      <clinit>(){
 *          System.out.println("A类静态代码块初始化");
 *           m=300;
 *           m=100;
 *      }
 */
public class Test05 {
    public static void main(String[] args) {
        A a=new A();
        System.out.println(a.m);

    }
}

class A{
    static{
        System.out.println("A类静态代码块初始化");
        m=300;
    }
    static int m=100;
    public A(){
        System.out.println("A类的无参构造初始化");
    }
}

在这里插入图片描述

/**
 *测试类什么时候会初始化
 */
public class Test06 {
    static {
        System.out.println("main方法被加载");
    }
    public static void main(String[] args) {
        //主动引用
        //Son son=new Son();
        //反射也会产生主动引用
        //Class.forName("com.Annotation.Reflection.Son");

        //不会产生类的引用的方法
        //System.out.println(Son.b);
       // Son[] array=new Son[5];
        System.out.println(Son.M);
    }
}
class Father{
    static{
        System.out.println("父类被加载");
    }
    static int b=2;
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        int m=0;
    }
    private int m=300;
    static final int M=1;

}

2.3通过反射获取运行时类的完整结构

Field（成员变量），Method（方法），Constructor（构造器），SuperClass（父类），Interface（接口），Annotation（注解）

package com.Annotation.Reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 获得类的信息
 */
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.Annotation.Reflection.user");

        //获得类的名字
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());
        //获取类的属性
        Field[] field = c1.getFields();//只能找到public属性
        field =c1.getDeclaredFields();//找到所有的属性
        for (Field field1 : field) {
            System.out.println(field1);
        }
        System.out.println("=============================");
        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
        //获得类的方法
        Method[] method = c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method1 : method) {
            System.out.println("正常的:  "+method1);
        }
        System.out.println("=============================");
        method =c1.getDeclaredMethods();//获得本类的所有方法
        for (Method method1 : method) {
            System.out.println("getDeclaredMethods:  "+method1);
        }
        //获得指定的方法
        System.out.println("=============================");
        Method getName = c1.getMethod("getName");
        Method setName = c1.getMethod("setName", String.class);

        System.out.println(getName);
        System.out.println(setName);
        System.out.println("=============================");
        //获得指定的构造器
        Constructor[] con = c1.getConstructors();//获得public的构造器
        for (Constructor constructor : con) {
            System.out.println(constructor);
        }
        con = c1.getDeclaredConstructors();//获得所有的构造器
        for (Constructor constructor : con) {
            System.out.println("515  "+constructor);
        }
        //获得指定的构造器
        Constructor con1 = c1.getConstructor(String.class, int.class, int.class);
        System.out.println("获得指定的构造器  "+con1);
    }
}

2.4通过反射动态的创建对象

import java.lang.reflect.Method;

/**
 *动态的创建对象，通过反射
 */
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得一个class对象
        Class c1 = Class.forName("com.Annotation.Reflection.user");

//        //构造一个对象
//        user use = (user)c1.newInstance();//本质调用了类的无参构造器
//        System.out.println(use);
//
//        //通过构造器来创造对象
//        Constructor Constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
//        user use2 = (user)Constructor.newInstance("派大星", 101, 10);
//        System.out.println(use2);

        //通过反射调用普通方法
        user use3 = (user) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(use3,"派大星啊啊啊");
        System.out.println(use3.getName());
        //通过反射操作属性
        user use4 = (user) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性，需要设置可访问性--setAccessible(true);
        name.setAccessible(true);//设置可访问性，true可以进行访问
        name.set(use4,"派小星");
        System.out.println(use4.getName());
    }
}

2.5通过反射获取注解信息

ackage com.Annotation.Reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
/**
 *反射操作注解
 */
public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.Annotation.Reflection.pop");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解的value的值。
        pxx pxx = (pxx)c1.getAnnotation(pxx.class);
        String value = pxx.value();
        System.out.println(value);

        //获得类指定的注解
        Field f1 = c1.getDeclaredField("name");
        filed annotation = f1.getAnnotation(filed.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());


    }
}
@pxx("db_sutdent")
class pop{
    @filed(columnName = "db_id",type="int",length = 10)
    private int id;
    @filed(columnName = "db_name",type="varchar",length = 3)
    private String name;
    @filed(columnName = "db_aeg",type="int",length = 10)
    private int age;

    public pop() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    @Override
    public String toString() {
        return "pop{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface pxx{
    String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface filed{
    String columnName();
    String type();
    int length();
}

推荐大家去b站看狂神的java视频

遇见狂神说

学徒易大师
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
注解与反射知识详解
qq_52253798的博客
03-28 803
一、什么是注解 （1） Annotation 是从JDK5.0开始引入的新技术。 （2）Annotation 的作用： 不是程序本身，可以对程序作出解释这一点和注释（ comment 没什么区别） 可以被其他程序（比如：编译器等）读取 （3）Annotation 的格式： 注解是以“＠注釋名”在代码中存在的还可以添加一些参数值，例如：@ SuppressWarnings ( value =" unchecked ")； （4） Annotation 在哪里使用？...
java注解与反射
Imzhipo的博客
03-14 456
java注释与反射
Java注解与反射
weixin_64026220的博客
07-20 774
Java注解与反射的学习
注解 与反射
weixin_49606056的博客
10-10 181
注解 与反射 什么是注解? 在java1.5的时候加入,使用@注释名,声明的就是注解了 什么是元注解? 负责注解其他注解,有4个 @Target:用于描述注解是使用范围 @Retention:用于描述生命周期 @Document用于携带注释 @Inherited:说明子类可以继承父类中的该注解 什么是反射 在运行期间使用对象名称动态获取对象的属性和方法,进行操作 构建Class对象的有几种方式? 1.Class.forName(类全限定名) 2.实例对象.getClass(); 需要一个创建好的对象来使用
java 注解与反射_Java注解与反射原理说明
weixin_42284380的博客
02-12 175
一点睛注解若想发挥更大作用，还需借助反射机制之力。通过反射，可以取得一个方法上声明的注解的全部内容。一般有两种需求：1取得方法中全部的注解，通过调用getAnnotations来实现。2判断操作是否是指定注解，通过调用getAnnotation来实现。下面从源码角度来说明怎样获取这些注解信息。二 源码导读——取得方法中全部的注解public class AccessibleObject im...
【注解与反射】简明阐述Java中的注解与反射
Suprit's blog
02-03 476
注解概述 注解和反射是所有Java框架的底层。注解(Annotation)是给计算机看的，可以被计算机读取；注释(Comet)是给人看的。 注解可以在package, class, method, fiel上使用，注解的本质则是通过反射机制实现对这些元数据的访问。 内置注解 @Override 方法重写 @Deprecated 表明该元素已弃用，不推荐使用 @SuppresWarnings 抑制（关闭）编译时的警告信息 元注解 元注解的作用是负责注解说明其他注解，Java定义了4个标
Java注解——注解与反射的结合
qq_55092103的博客
07-21 252
注解是JDK1.5之后的新特性，可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释，也叫元数据。注解是说明程序的，给计算机看的标签• @Override ：检测被该注解标注的方法是否是继承自父类(接口)• @Deprecated：该注解标注的内容，表示已过时• @SuppressWarnings：压制警告，可以剔除编译时抛出的警告一般传递参数all @SuppressWarnings(“all”)
【Java基础】注解与反射
qq_42294095的博客
05-30 818
@Override、@Deprecated、@SuppressWarnings、annotation、Reflection、ORM
注释与反射
conquer112的博客
10-24 2117
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录注释和反射注释反射机制（Reflection） 注释和反射 注释 注释 ： annotation 注解：comment annotaion的作用： 不是程序本身，但可以对程序做出解释（与comment 类似） 可以被其他程序读取，如编译器。 annotation 在那里使用？ 可以附加在package，class，method，field 等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制实现对这些元
Java注解与反射原理说明
08-26
当注解与反射结合时，我们可以利用反射机制来读取和处理注解中的信息。在Java中，`AnnotatedElement`接口提供了获取注解的方法，包括`getAnnotations()`和`getAnnotation(Class<T> annotationClass)`。 1. `...
注解与反射高效开发法.pdf
05-26
总之，注解与反射是Java语言的核心高级特性之一，它们能够提供强大的代码动态性，对于实现框架设计、简化代码编写等都有极大的帮助。Java开发者应当充分理解和掌握这些高级特性，以便在实际开发中运用自如。
反射操作注解与反射操作泛型.docx
04-16
反射操作注解与反射操作泛型 在 Java 编程中，反射操作和泛型是两个重要的概念。反射操作是指在运行时检查和修改类、对象、方法、字段等信息的能力，而泛型是指在编译时检查和限制类型的能力。本文将详细介绍反射...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
JavaSE-注解与反射(框架底层实现机制)
12-21
JavaSE中的注解（Annotation）和反射（Reflection）是两种非常重要的编程特性，它们在现代Java框架和库的实现中起着至关重要的作用。自从JDK5.0引入注解以来，它已经成为编写更加优雅、可维护代码的一种手段。而反射...
JAVA进阶补充
2301_80150315的博客
08-15 885
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 577
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1049
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 362
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
Java注解与反射机制详解
内置注解与元注解 #### 2.1 内置注解 Java提供了一些内置注解，如`@Override`、`@Deprecated`和`@ SuppressWarnings`。此外，还有`@FunctionalInterface`，它用于标记接口为函数式接口，确保该接口只有一个抽象方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值