注解 订阅
注解是一个汉语词汇,读音为zhù jiě,意思是用文字来解释字句;泛指解释;解释字句的文字;神鬼名。民间传说指阴司第一阎王殿中职掌解送鬼魂并令其注册者。 展开全文
注解是一个汉语词汇,读音为zhù jiě,意思是用文字来解释字句;泛指解释;解释字句的文字;神鬼名。民间传说指阴司第一阎王殿中职掌解送鬼魂并令其注册者。
信息
注    音
ㄓㄨˋ ㄐㄧㄝ ˇ
拼    音
zhù jiě
出    自
《后汉书·儒林传上·杨伦》
中文名
注解
注解基本信息
词目:注解近义词:注明 注脚 注释 表明 解说 解释 讲明 评释 [1]  反义词:正文 [1] 
收起全文
精华内容
下载资源
问答
  • 注解
    千次阅读
    2022-04-12 21:15:40

    写在前面,本人初次整理关于java的有关概念,难免有误和不足之处,还望能得到大家多多指正,一起进步。

    1.注释

    1.什么是注释?

    注释是解释说明程序的文字分类。注释是程序员对源代码的类,方法,属性等做的一些记忆或提示性描述(比如这个方法是做什么用的),是给人来看的。

    2.单行注释

    用//来表示:可以写在任何一行代码前。

    3.多行注释

    用/* */来表示:可以写在任何一行代码前,不能和单行注释嵌套使用。

    4.文档注释

    用/** */来表示:只能写在类或成员之前,编译时可以生成API文档。

    一、注释
    虽然注解、注释只相差一个字,但是用法就差异很大。
    还是那句话, 注解给编译器看, 注释是给人看的。
    基于此的话, 对于一个方法来说:
    1. 把这个方法的作用, 输入,输出描述清楚就可以了,更多的可以加上一些作者呀,版本呀这样一些信息
    2. 注释编排的美观一些
    做到这两点应该就可以了。 举个例子:

    /******************************************************************************* 
    * NAME:     usage 
    * DESCRIPTION: XXX 
    * ARGUMENTS:  N/A 
    * RETURN:    
    * AUTHOR:    oscar999 
    * VERSION:   V0.1 
    *******************************************************************************/ 
    
    

    看上去这是一个不错的注释^^.

    但是对于Java 语言来说, 注释被赋予了更多的功能。 就是你可以使用javadoc 这个功能把代码中的注释导出到  html 的文件中。
    如果你的代码是共用性很高的代码的话, 这份文档就是一份API的参考文档, 类似Java API.
    所以, 要产生出这样的文档,就要遵循java 定义的一些注释规范, 才能产生出规范的文档出来。

    二、Java 类方法的标准注释
    还是从类的方法的注释说起。

      /** 
       * Read a line of text. A line is considered to be terminated by any one 
       * of a line feed ('\n'), a carriage return ('\r'), or a carriage return 
       * followed immediately by a linefeed. 
       * 
       * @param   ignoreLF1 If true, the next '\n' will be skipped 
    <pre code_snippet_id="74911" snippet_file_name="blog_20131120_2_8365599" name="code" class="java">   * @param   ignoreLF2 If true, the next '\n' will be skipped</pre>   *   * @return   A String containing the contents of the line, not including   *       any line-termination characters, or null if the end of the   *       stream has been reached   *   * @see    java.io.LineNumberReader#readLine()   *   * @exception IOException If an I/O error occurs   */ 
    
    
    

    (不去关注以上注释的意义,只关注其定义的样式)
    1. 首先看最上面的 “Read a line of text.  A line .. ” 这一段是对这个方法的一些描述。

    第一个句号前面的部分, 也就是 “Read a line of text.” 会出现在 “方法摘要” 中

    2. @param 定义的是方法的输入参数,(可以添加多个)出现在“ 方法详细信息” 中。(参数和参数描述之间使用空格隔开, 在产生的文档中转成了  -)

    3. @return  返回值的描述

    4. @see  参考的描述

    5. @exception 异常抛出的描述
    美观考虑, 不同类的标签可以换一行显示, 比如 @param 和 @return 直接空一行。

    三、Java 类标准注释
    类的注释和方法注释的格式基本相同。 区别的地方:
    1. 放置的位置不同。 类的注释放在类定义的上面, 方法的注释放在方法定义的上面。
    2. 类的注释比较会使用   @version  @author  @since 这样的标签。
    看模板

    /** will buffer the input from the specified file. Without buffering, each 
    * invocation of read() or readLine() could cause bytes to be read from the 
    * file, converted into characters, and then returned, which can be very 
    * inefficient. 
    * 
    * 
    * Test Description 
    * 
    * <p> Programs that use DataInputStreams for textual input can be localized by 
    * replacing each DataInputStream with an appropriate BufferedReader. 
    * 
    * @see FileReader 
    * @see InputStreamReader 
    * 
    * @version 0.1, 11/20/13 
    * @author  oscar999 
    * @since  JDK1.5 
    */ 

    2.注解

    java注解(Annotation)又称java标注,是JDK5.0引入的一种注释机制。与类、接口、枚举是在同一个层次,可以成为java 的一个类型。

    java语言中的类、方法、变量、参数和包等都可以被标注。

    注解则是Java 编译器可以理解的部分,是给编译器看的。

    一、常见的Java 内置注解
    除了包含@Override (方法重写的注解)。

    还有哪些常见的Java内置注解? 

    1. @Deprecated

    注解为不建议使用,可以用在 方法和类上。
    基本上这种方法和类都是因为升级或性能上面的一些原因废弃不建议使用,但是为了兼容或其他原因,还必须保留。
    所以就打上这个注解。
    在Java 本身的API中就有很多这样的例子, 方法打上了这个注解,进到Source code 会看到替代的新的方法是哪个。
    在eclipse 中编写code时,添加此注解的方法在声明和调用的地方都会加上删除线。

    2.@Override

    3.@SuppressWarnings
    忽略警告。
    如果你的code在转型或其他的部分有一些警告的话,但是你又想忽略这些警告,就可以使用这个注解了。
    1)deprecation 使用了不赞成使用的类或方法时的警告

    2)unchecked 执行了未检查的转换时警告

    3)fallthrough 当使用switch操作时case后未加入break操作,而导致程序继续执行其他case语句时出现的警告

    4)path 当设置一个错误的类路径、源文件路径时出现的警告

    5)serial 当在可序列化的类上缺少serialVersionUID定义时的警告

    6)fianally 任何finally子句不能正常完成时警告

    7)all 关于以上所有情况的警告

    二、自定义注解

    除了Java本身提供的内置注解, Java 还提供了定制自定义注解的功能。
    定义的方式就是使用注解定义注解, 用来定义注解的注解称为元注解。
    主要的元注解有以下四个:@Target ;@Retention;@Documented;@Inherited
    1. @Target 表示该注解用于什么地方,使用在类上,方法上,或是属性等
    可能的 ElemenetType 参数包括:
    ElemenetType.CONSTRUCTOR 构造器声明
    ElemenetType.FIELD 域声明(包括 enum 实例)
    ElemenetType.LOCAL_VARIABLE 局部变量声明
    ElemenetType.METHOD 方法声明
    ElemenetType.PACKAGE 包声明
    ElemenetType.PARAMETER 参数声明
    ElemenetType.TYPE 类,接口(包括注解类型)或enum声明
    2. @Retention 表示在什么级别保存该注解信息
    可选的 RetentionPolicy 参数包括:
    RetentionPolicy.SOURCE 注解将被编译器丢弃
    RetentionPolicy.CLASS 注解在class文件中可用,但会被VM丢弃
    RetentionPolicy.RUNTIME VM将在运行期也保留注释,因此可以通过反射机制读取注解的信息。
    3. @Documented ,产生doc时,是否包含此注解
    将此注解包含在 javadoc 中
    4.  @Inherited
    允许子类继承父类中的注解

    三、Annotation的作用

    介绍到此,可以总结一下Annotation的作用了。
    基础的大致可以分为三类:
    1. 编写文档
    2. 代码分析
    3. 编译检查
    但是,开源框架对其赋予了更多的作用
    比如:
    Hibernate,注解配置,

    @Column("aa") 
    private String xx; 
    

    这个类似于XML配置,简化程序中的配置
    相对与把一部分元数据从XML文件移到了代码本身之中,在一个地方管理和维护。
    内部如何实现的?

    -- java 反射机制,类似与以上例子。

    四、注解注意的几个事项

    1.注解用法和修饰符用法类似

    2.注解不能修饰代码块、实参

    3.注解可以连用(即注解可以被注解修饰)、JDK1.8以后注解可以重复使用

    4.无参注解在使用时可以省略括号,带参注解不能省略括号

    5.注解不能被继承,枚举(enum)也不能被继承

    6.注解可以被实现

    7.使用注解,需要在注解里添加抽象方法,然后可以用有参注解给抽象方法传值

    8.注解里不能写返回值为void的抽象方法

    package top.guofei.cordjava.day02.ds;
    
    public enum Sex {
        MALE,FEMALE;
    }
    
    package top.guofei.cordjava.day02.ds;
    
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.reflect.Field;
    
    /**
     * @Gender  注解
     * 注解里的value()抽象方法不需要方法名调用
     * @Retention(RetentionPolicy.SOURCE)  编译时会丢失
     * @Retention(RetentionPolicy.CLASS)    运行是被丢弃
     * @Retention(RetentionPolicy.RUNTIME)  会被反射获得
     */
    
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Gender {
        Sex  value();
    }
    
    class Person{
        @Gender(Sex.FEMALE)
        Sex sex=Sex.MALE;
    
        @Override
        public String toString() {
            return sex.equals(Sex.MALE)?"男":"女";
        }
    }
    class  MainTest{
        public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
            Person person=new Person();
            Class<Person> personClass=Person.class;
    
            Field sexfield=personClass.getDeclaredField("sex");
            Sex  sex=sexfield.getAnnotation(Gender.class).value();
            sexfield.set(person,sex);
    
            System.out.println(person);
        }
    }

    更多相关内容
  • 注解注释以及Spring和SpringMVC常用的注解 1.两者区别 注解 :参与代码编译,以@开头的。它是给应用程序看的,单独使用注解毫无意义,一定要跟工具一起使用,这个所谓的工具实际就是能读懂注解的应用程序  注释 :...
  • mybatis逆向工程 自定义添加注解以及注释、mapper,对框架前期搭建相当实用
  • 主要介绍了Java中的注解注释,简单来说注解以@符号开头而注释被包含在/***/符号中,各自具体的作用则来看本文详解,需要的朋友可以参考下
  • Java——注解/注释

    2022-04-03 15:49:09
    1、注解,或者叫做注释类型,英文单词是:Annotation 2、注解Annotation是一种引用数据类型。编译之后也是生成xxx.class文件。 3、怎么自定义注解呢?语法格式? [修饰符列表] @interface 注解类型名{ } 4...

    目录

    注解概述

    JDK内置的注解

    元注解

    Override注解 

    Deprecated

    注解中自定义属性

    value();

    注解中的属性类型

    属性是一个数组

    Retention的源代码

    反射注解

    通过反射机制获取属性对象的值 

    通过反射机制获取注释信息


    注解概述

        1、注解,或者叫做注释类型,英文单词是:Annotation

        2、注解Annotation是一种引用数据类型。编译之后也是生成xxx.class文件。

        3、怎么自定义注解呢?语法格式?

             [修饰符列表] @interface 注解类型名{

             }
        4、注解怎么使用,用在什么地方?

            第一:注解使用时的语法格式是:
                @注解类型名
            
            第二:注解可以出现在类上、属性上、方法上、变量上等....
            注解还可以出现在注解类型上。

    自定义注解:MyAnnotation 

    
    public @interface MyAnnotation {
        // ??????
    }

    @MyAnnotation
    public class AnnotationTest01 {
    
        @MyAnnotation
        private int no;
    
        @MyAnnotation
        public AnnotationTest01(){}
    
        @MyAnnotation
        public static void m1(){
            @MyAnnotation
            int i = 100;
        }
    
        @MyAnnotation
        public void m2(@MyAnnotation
                       String name,
                       @MyAnnotation
                       int k){
    
        }
    }
    
    @MyAnnotation
    interface MyInterface {
    
    }
    
    @MyAnnotation
    enum Season {
        SPRING,SUMMER,AUTUMN,WINTER
    }

    注解修饰注解。 

    
    @MyAnnotation
    public @interface OtherAnnotation {
    }

    默认情况下,注解可以出现在任意位置。


    JDK内置的注解

     java.lang包下的注解

    (掌握)

    Deprecated

    用 @Deprecated 注释的程序元素,不鼓励程序员使用这样的元素,通常是因为它很危险或存在更好的选择。

    (掌握)

    Override

    表示一个方法声明打算重写超类中的另一个方法声明。

    (了解)

    SuppressWarnings

    指示应该在注释元素(以及包含在该注释元素中的所有程序元素)中取消显示指定的编译器警告。

    元注解

            什么是元注解?
                用来标注“注解类型”的“注解”,称为元注解。

            常见的元注解有哪些?
                Target
                Retention
            
            关于Target注解:
                这是一个元注解,用来标注“注解类型”的“注解”
                这个Target注解用来标注“被标注的注解”可以出现在哪些位置上。

                @Target(ElementType.METHOD):表示“被标注的注解”只能出现在方法上。
                @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
                    表示该注解可以出现在:
                        构造方法上
                        字段上
                        局部变量上
                        方法上
                        ....
                        类上...
            
            关于Retention注解:
                这是一个元注解,用来标注“注解类型”的“注解”
                这个Retention注解用来标注“被标注的注解”最终保存在哪里。

                @Retention(RetentionPolicy.SOURCE):表示该注解只被保留在java源文件中。
                @Retention(RetentionPolicy.CLASS):表示该注解被保存在class文件中。
                @Retention(RetentionPolicy.RUNTIME):表示该注解被保存在class文件中,并且可以被反射机制所读取。


    Override注解 

    源码:

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Override {
    }
    

    @Override

    标识性注解,给编译器做参考的。
    编译器看到方法上有这个注解的时候,编译器会自动检查该方法是否重写了父类的方法。
    如果没有重写,报错。

    这个注解只是在编译阶段起作用,和运行期无关!

    // @Override这个注解只能注解方法。
    // @Override这个注解是给编译器参考的,和运行阶段没有关系
    // 凡是java中的方法带有这个注解的,编译器都会进行编译检查,如果这个方法不是重写父类的方法,编译器报错。

    Deprecated

    Deprecated这个注解标注的元素已过时。
    这个注解主要是向其它程序员传达一个信息,告知已过时,有更好的解决方案存在。

    // 表示这个类已过时。
    @Deprecated
    public class AnnotationTest03 {
    
        @Deprecated
        private String s;
    
        public static void main(String[] args) {
            AnnotationTest03 at = new AnnotationTest03();
            at.doSome();
        }
    
        @Deprecated
        public void doSome(){
            System.out.println("do something!");
        }
    
        // Deprecated这个注解标注的元素已过时。
        // 这个注解主要是向其它程序员传达一个信息,告知已过时,有更好的解决方案存在。
        @Deprecated
        public static void doOther(){
            System.out.println("do other...");
        }
    }
    
    class T {
        public static void main(String[] args) {
            AnnotationTest03 at = new AnnotationTest03();
            at.doSome();
    
            AnnotationTest03.doOther();
    
            try {
                Class c = Class.forName("java.util.Date");
                Object obj = c.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    注解中自定义属性

    public @interface MyAnnotation {
    
        /**
         * 我们通常在注解当中可以定义属性,以下这个是MyAnnotation的name属性。
         * 看着像1个方法,但实际上我们称之为属性name。
         * @return
         */
        String name();
    
        /*
        颜色属性
         */
        String color();
    
        /*
        年龄属性
         */
        int age() default 25; //属性指定默认值
    
    }
    public class MyAnnotationTest {
    
        // 报错的原因:如果一个注解当中有属性,那么必须给属性赋值。(除非该属性使用default指定了默认值。)
        /*@MyAnnotation
        public void doSome(){
    
        }*/
    
        //@MyAnnotation(属性名=属性值,属性名=属性值,属性名=属性值)
        //指定name属性的值就好了。
        @MyAnnotation(name = "zhangsan", color = "红色")
        public void doSome(){
    
        }
    }

    value();

    如果一个注解的属性的名字是value,并且只有一个属性的话,在使用的时候,该属性名可以省略。

    public @interface MyAnnotation {
    
        /*
        指定一个value属性。
         */
        String value();
    
        //String email();
    }
    public class MyAnnotationTest {
    
        @MyAnnotation(value = "hehe")
        public void doSome(){
    
        }
    
        @MyAnnotation("haha")
        public void doOther(){
    
        }
    }
    

    注解中的属性类型

    注解当中的属性可以是哪一种类型?
            属性的类型可以是:
                byte short int long float double boolean char String Class 枚举类型
                以及以上每一种的数组形式。

    public @interface MyAnnotation {
    
        int value1();
    
        String value2();
    
        int[] value3();
    
        String[] value4();
    
        Season value5();
    
        Season[] value6();
    
        Class parameterType();
    
        Class[] parameterTypes();
    }
    public enum Season {
        SPRING,SUMMER,AUTUMN,WINTER
    }

    属性是一个数组

        // 数组是大括号
        @OtherAnnotation(age = 25, email = {"zhangsan@123.com", "zhangsan@sohu.com"}, seasonArray = Season.WINTER)
        public void doSome(){
    
        }
    
        // 如果数组中只有1个元素:大括号可以省略。
        @OtherAnnotation(age = 25, email = "zhangsan@123.com", seasonArray = {Season.SPRING, Season.SUMMER})
        public void doOther(){
    
        }

    Retention的源代码

                //元注解    
                public @interface Retention {
                    //属性
                    RetentionPolicy value();
                }
                
            RetentionPolicy的源代码:
                public enum RetentionPolicy {
                     SOURCE,
                     CLASS,
                     RUNTIME
                }

                //@Retention(value=RetentionPolicy.RUNTIME)
                @Retention(RetentionPolicy.RUNTIME)
                public @interface MyAnnotation{}


    反射注解

    通过反射机制获取属性对象的值 

    //只允许该注解可以标注类、方法
    @Target({ElementType.TYPE, ElementType.METHOD})
    // 希望这个注解可以被反射
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation {
    
        /*
        value属性。
         */
        String value() default "沈阳大街";
    }
    //Test
    
    @MyAnnotation("山东菏泽曹县")
    public class MyAnnotationTest {
    
        //@MyAnnotation
        int i;
    
        //@MyAnnotation
        public MyAnnotationTest(){
    
        }
    
        @MyAnnotation
        public void doSome(){
    
            //@MyAnnotation
            int i;
        }
        public static void main(String[] args) throws Exception{
            // 获取这个类
            Class c = Class.forName("lit.jxxy.rg1508.java.annotation5.MyAnnotationTest");
            // 判断类上面是否有@MyAnnotation
            //System.out.println(c.isAnnotationPresent(MyAnnotation.class)); // true
            if(c.isAnnotationPresent(MyAnnotation.class)){
                // 获取该注解对象
                MyAnnotation myAnnotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
                //System.out.println("类上面的注解对象" + myAnnotation); // @lit.jxxy.rg1508.java.annotation5.MyAnnotation()
                // 获取注解对象的属性怎么办?和调接口没区别。
                String value = myAnnotation.value();
                System.out.println(value);
            }
    
            // 判断String类上面是否存在这个注解
            Class stringClass = Class.forName("java.lang.String");
            System.out.println(stringClass.isAnnotationPresent(MyAnnotation.class)); // false
        }

    通过反射机制获取注释信息

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface MyAnnotation {
    
        /*
        username属性
         */
        String username();
    
        /*
        password属性
         */
        String password();
    }

        @MyAnnotation(username = "admin", password = "456456")
        public void doSome(){
    
        }
    
        public static void main(String[] args) throws Exception{
            // 获取MyAnnotationTest的doSome()方法上面的注解信息。
            Class c = Class.forName("lit.jxxy.rg1508.java.annotation6.MyAnnotationTest");
            // 获取doSome()方法
            Method doSomeMethod = c.getDeclaredMethod("doSome");
            // 判断该方法上是否存在这个注解
            if(doSomeMethod.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation myAnnotation = doSomeMethod.getAnnotation(MyAnnotation.class);
                System.out.println(myAnnotation.username());
                System.out.println(myAnnotation.password());
            }
        }

    注解在开发中的作用

         需求:
                假设有这样一个注解,叫做:@Id
                这个注解只能出现在类上面,当这个类上有这个注解的时候,
                要求这个类中必须有一个int类型的id属性。如果没有这个属性
                就报异常。如果有这个属性则正常执行!

    // 表示这个注解只能出现在类上面
    @Target(ElementType.TYPE)
    // 该注解可以被反射机制读取到
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MustHasIdPropertyAnnotation {
    
    }
    
    // 这个注解@Id用来标注类,被标注的类中必须有一个int类型的id属性,没有就报异常。
    @MustHasIdPropertyAnnotation
    public class User {
        int id;
        String name;
        String password;
    }
    /*
    自定义异常
     */
    public class HasNotIdPropertyException extends RuntimeException {
        public HasNotIdPropertyException(){
    
        }
        public HasNotIdPropertyException(String s){
            super(s);
        }
    }
        public static void main(String[] args) throws Exception{
            // 获取类
            Class userClass = Class.forName("lit.jxxy.rg1508.java.annotation7.User");
            // 判断类上是否存在Id注解
            if(userClass.isAnnotationPresent(MustHasIdPropertyAnnotation.class)){
                // 当一个类上面有@MustHasIdPropertyAnnotation注解的时候,要求类中必须存在int类型的id属性
                // 如果没有int类型的id属性则报异常。
                // 获取类的属性
                Field[] fields = userClass.getDeclaredFields();
                boolean isOk = false; // 给一个默认的标记
                for(Field field : fields){
                    if("id".equals(field.getName()) && "int".equals(field.getType().getSimpleName())){
                        // 表示这个类是合法的类。有@Id注解,则这个类中必须有int类型的id
                        isOk = true; // 表示合法
                        break;
                    }
                }
    
                // 判断是否合法
                if(!isOk){
                    throw new HasNotIdPropertyException("被@MustHasIdPropertyAnnotation注解标注的类中必须要有一个int类型的id属性!");
                }
    
            }
        }

    展开全文
  • Java注解注释

    2020-05-11 14:32:31
    文章目录JDK内置注解`@Override``@Deprecated``@SuppressWarnings`元注解概述`@Retention``@Target``@Documented``@Inherited`自定义注解通过...注解获取属性的注解获取构造器的注解获取方法的注解获取参数注解**注意...

    JDK内置注解

    @Override

    @Override的作用是标记重写父类的方法,@Override只能用于标记方法。编译器编译时会校验使用@Override标记的方法是否与父类对应方法形式一致。例:

    Man.java

    public class Man{
        private String name;
        private float height;
        private int weight;
        public void setName(String name){};
        public void setHeight(float height){};
        public void setWeight(int weight){};
    }
    

    Woman.java

    public class Woman extends Man{
        @Override
        public void setHeight(int height){
            //编译时会报错,因为形参与父类不同
        }
    }
    

    @Deprecated

    @Deprecated用于提示所修饰的元素(类、方法、变量等)已过时,继续使用可能会发生危险或者存在更好的选择。JDK更新过程中不会删除过时的API,而是为这些API加上@Deprecated标签,使得JDK不建议用户继续使用该API的同时,也保证使用了过时API的旧项目能正常运行。

    @SuppressWarnings

    @SupressWarnings的作用是抑制编译器警告。可以用于修饰所有成员。例如一个成员定义了却未使用(unused),就可以使用@SupressWarnings("unused")来抑制成员未使用(unused)的警告。再例如使用原类型时抑制警告:

    @SupressWarnings({"unused","rawtypes"})
    ArrayList list = new ArrayList();   //使用了ArrayList不带类型参数的原类型
    

    元注解

    概述

     元注解是用来修饰注解定义的注解。

    @Retention

    @Retention限定了被修饰注解的生命周期。它的取值有:

    //注解在源文件(java文件)中有效(源文件保留),编译时丢弃
    @Retention(RetentionPolicy.SOURCE)        
    //默认值。注解在class文件中有效(class保留),但不会加载到JVM
    @Retention(RetentionPolicy.CLASS)  
    //注解在运行时有效(运行时保留),JVM会保留注释,所以程序运行时可以通过反射机制获取到注解信息
    @Retention(RetentionPolicy.RUNTIME)       
    

    例:

    @Retention(RetentionPolicy.SOURCE)
    public @interface MyAnnotation{
        String[] value();
    }
    

    @Target

    @Target指定被修饰注解可以用来修饰程序中的哪些元素。取值有:

    TYPE:被修饰注解可以修饰class/interface/@interface/enum
    FIELD:被修饰注解可以修饰field
    METHOD:被修饰注解可以修饰method
    PARAMETER:被修饰注解可以修饰parameter
    CONSTRUCTOR:被修饰注解可以修饰constructor
    LOCAL_VARIABLE:被修饰注解可以修饰local variable(局部变量)
    ANNOTATION_TYPE:被修饰注解可以修饰Annotation type
    PACKAGE:被修饰注解可以修饰package
    TYPE_PARAMETER:被修饰注解可以修饰class parameter(泛型类型参数)
    TYPE_USE:被修饰注解可以修饰任何使用的元素。

    例:

    @Target({TYPE,METHOD,CONSTRUCTOR})   //该注解可以用于修饰 类、方法、构造器
    public @interface MyAnnotation{
        String[] value();
    }
    

    **注意:**若未指明@Target元注解,则该注解默认可以修饰程序中的所有元素。

    @Documented

     被@Documented修饰的注解修饰的成员在API文档中也会显示出相应的注解,而默认API文档中是不显示注解的。

    @Inherited

    @Inherited修饰的注解将具有继承性,即如果一个类被@Inherited修饰的注解修饰,这个类的子类将自动具有该注解。

    自定义注解

    使用@interface关键字定义注解:

    public @interface MyAnnotation{
        /*
          成员变量以“无参方法”的形式声明,“无参方法”的返回值即成员变量的值
        */
        int value();
        String message();
    }
    

    使用方法:

    //修饰类
    @MyAnnotation(value = 1,message = "type")
    public class Person{
        //修饰属性
        @MyAnnotation(value = 2,message = "field")
        private String name;
        //修饰构造器
        @MyAnnotation(value = 3,message = "constructor")
        public Person(String name){
            this.name = name;
        }
        //修饰方法
        @MyAnnotation(value = 4,message = "method")
        public String getName(){
            return name;
        }
        //修饰参数
        public void setName(@MyAnnotation(value = 5,message = "param") String name){
            this.name = name;
        }    
    }
    

    使用default关键字指定成员变量默认值:

    public @interface MyAnnotation{
        int value() default 0;
        String message() default "";
    }
    

    此时再使用时可以不用带参数从而直接使用默认值:

    @MyAnnotation
    public class Person{
        //也可以仅指定部分参数
        @MyAnnotation(message = "default test")
        public Person(String name){
            this.name = name;
        }
    }
    

    如果注解中没有成员,这个注解就是一个标识。例如@Override

    通过反射机制获取RUNTIME注解

    定义注解

    MyAnnotation.java

    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface MyAnnotation{
        int value() default 0;
        String message() default "";
    }
    

    Person

    Person.java

    @MyAnnotation(message = "Person")
    public class Person{
        @MyAnnotation(value = 1,message = "name")
        private String name;
        @MyAnnotation(value = 2,message = "height")
        private float height;
        @MyAnnotation(value = 3,message = "weight")
        private int weight;
        
        @MyAnnotation(value = 4,message = "Person()")
        public Person(String name,float height,int weight){
            this.name = name;
            this.height = height;
            this.weight = weight;
        }
        
        @MyAnnotation(value = 5,message = "setName()")
        public void setName(@MyAnnotation(value = 6,message = "paramName")String name){
            this.name = name;      
        }
        @MyAnnotation(value = 7,message = "getName()")
        public String getName(){
            return name;
        }
        
        @MyAnnotation(value = 8,message = "setHeight()")
        public void setHeight(@MyAnnotation(value = 9,message = "paramHeight")float height){
            this.height = height;
        }
        @MyAnnotation(value = 10,message = "getHeight()")
        public float getHeight(){
            return height;
        }
        
        @MyAnnotation(value = 11,message = "setWeight()")
        public void setWeight(@MyAnnotation(value = 12,message = "paramWeight")int weight){
            this.weight = weight;
        }
        @MyAnnotation(value = 13,message = "getWeight()")
        public int getWeight(){
            return weight;
        }
        
    }
    

    获取注解的方法

    //java.lang.annotation.Annotation
    public Annotation[] getAnnotations()
    
    //java.lang.annotation.Annotation
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
    
    //java.lang.annotation.Annotation
    public Annotation[] getDeclaredAnnotations()
    
    //java.lang.annotation.Annotation
    public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass)
    

    获取类的注解

    Class<Person> clas = Person.class;
    //获取注解
    MyAnnotation annotation = clas.getDeclaredAnnotation(MyAnnotation.class);
    //获取注解成员"value()"值
    int value = annotation.value();
    //获取注解成员"message()"值
    String message = annotation.message();
    System.out.println("value:"+value+",message:"+message);
    

    获取属性的注解

    Class<Person> clas = Person.class;
    //获取属性
    Field name = clas.getDeclaredField("name");
    //使可访问
    name.setAccessible(true);
    //获取注解
    MyAnnotation annotation = name.getDeclaredAnnotation(MyAnnotation.class);
    //获取注解成员"value()"值
    int value = annotation.value();
    //获取注解成员"message()"值
    String message = annotation.message();
    System.out.println("value:"+value+",message:"+message);
    

    获取构造器的注解

    Class<Person> clas = Person.class;
    //获取构造器
    Constructor<Person> cons =
        clas.getDeclaredConstructor(String.class,float.class,int.class);
    //使可访问
    cons.setAccessible(true);
    //获取注解
    MyAnnotation annotation = cons.getDeclaredAnnotation(MyAnnotation.class);
    //获取注解成员"value()"值
    int value = annotation.value();
    //获取注解成员"message()"值
    String message = annotation.message();
    System.out.println("value:"+value+",message:"+message);
    

    获取方法的注解

    Class<Person> clas = Person.class;
    //获取方法
    Method method = clas.getDeclaredMethod("setName",String.class);
    //使可访问
    method.setAccessible(true);
    //获取注解
    MyAnnotation annotation = method.getDeclaredAnnotation(MyAnnotation.class);
    //获取注解成员"value()"值
    int value = annotation.value();
    //获取注解成员"message()"值
    String message = annotation.message();
    System.out.println("value:"+value+",message:"+message);
    

    获取参数注解

    Class<Person> clas = Person.class;
    //获取方法(或构造器)
    Method method = clas.getDeclaredMethod("setHeight",float.class);
    //使可访问
    method.setAccessible(true);
    //获取参数
    Parameter param = (method.getParameters())[0];
    //获取注解
    MyAnnotation annotation = param.getDeclaredAnnotation(MyAnnotation.class);
    //获取注解成员"value()"值
    int value = annotation.value();
    //获取注解成员"message()"值
    String message = annotation.message();
    System.out.println("value:"+value+",message:"+message);
    

    注意:

    只有包含@Retention(RetentionPolicy.RUNTIME)修饰的注解才能使用反射机制获取。

    说明注释

    概述

     Java中有三种注释形式:1.以//开头的单行注释;2.以/*开头*/结尾的多行注释;3.以/**开头*/结尾的说明注释

    说明注释允许在程序中嵌入对程序的说明信息,生成API文档作为API调用时的指导。

    说明注释中可以包含以@开头标签,用于对特定信息的描述,例如作者、版本、方法参数和方法返回值等。

    常用的说明注释标签

    1.@author:用于注释。说明类的作者。例:

    /**
    *@author Lishaoyin
    */
    public class Person{}
    

    2.@version:用于注释。说明类的版本。例:

    /**
    *@version 1.0
    */
    public class Person{}
    

    3.@since:用于类和任意类成员注释。说明API是在JDK的哪个版本添加的。例:

    /**
    *@since 1.8
    */
    public void setName(String name){}   //API在JDK1.8添加
    

    4.@deprecated:用于类和任意类成员注释。说明该类成员已过期,不建议使用。例:

    /**
    *@deprecated this field is deprecated,you can use better choice
    */
    private String name;
    

    5.@throws:用于方法和构造器注释。说明方法或构造器可能会抛出的异常。例:

    /**
    *@throws java.io.IOException this method maybe throws IOException
    */
    public void setHeight(float height) throws IOException {}
    

    6.@exception:作用与@throws相同。

    7.@see:用于类和任意类成员注释。在生成的文档中指定一个API文档超链接,用户点击后可跳转至指定内容的API文档。例:

    /**
    *@see java.lang.annotation.Annotation
    */
    public class Person{}
    

    8.@param:用于方法和构造器注释。说明方法或构造器的参数。例:

    /**
    *@param name String,person's name
    *@param height float,person's height
    *@param weight int,person's weight
    */
    public Person(String name,float height,int weight){}
    

    9.@return:用于方法注释。说明方法的返回值。

    /**
    *@return String,person's name
    */
    public String getName(){}
    

    TODO

    TODO是一种用法简单的计划标记工具,其作用是将计划指示信息嵌入到注释中(可嵌入到三种注释中的任意一种)。编译后可使用快速定位跳转到指定计划位置,继续完成计划中未完成的工作。例:

    public class Person{
        
        public String getName(){
           //TODO function to get person's name 
        }
        
        public void setHeight(float height){
           /*TODO function to set person's height*/
        }
        
        /**
        *@param weight int,set person's weight
        *TODO function to set person's weight
        */
        public String setWeight(int weight){}
        
    }
    

    示例

    Person.java

    /**
    *@author Lishaoyin
    *version 1.0
    *@since 1.8
    */
    public class Person{
        
        private String name;
        private float height;
        private int weight;
        
        /**
        *@param name String,init person's name
        *@param height float,init person's height
        *@param weight int,init person's weight
        */
        public Person(String name,float height,int weight){
            this.name = name;
            this.height = height;
            this.weight = weight;
        }
        
        /**
        *@param name String,set person's name
        */
        public void setName(String name){
            this.name = name;
        } 
        /**
        *@return String,get person's name
        */
        public String getName(){
            return name;
        }
        
        /**
        *@param height float,set person's height
        */
        public void setHeight(float height){
            this.height = height;
        } 
        /**
        *@return float,get person's height
        */
        public float getHeight(){
            return height;
        }
        
        /**
        *@throws java.io.IOException this method maybe throws IOException
        *@see java.io.IOException
        *@param weight int,set person's weight
        */
        public void setWeight(int weight) throws java.io.IOException {
            this.weight = weight;
        }
        /**
        *@return int,get person's weight
        */
        public int getWeight(){
            return weight;
        }
        
        //TODO function to set person's sex
        
    }
    
    展开全文
  • 全面解析Java注解

    2020-12-22 21:35:39
    1、了解注解  我们有必要对JDK 5.0新增的注解(Annotation)技术进行简单的学习,因为Spring 支持@...这些@param、@return等Javadoc标签是注解标签,它们为第三方工具提供了描述程序代码的注释信息。使用过Xdoclet
  • 西门子S7200的程序集合,里面有详细注释
  • 主要功能是,生成实体类带数据库中文注解,去掉set,get方法用@Data注解实现
  • 注释注解JAVA注解

    2021-02-25 18:55:11
    } } 4、@SuppressWarnings注解: java.lang 注释型类 SuppressWarnings @Target(value={TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE}) @Retention(value=SOURCE) public @interface SuppressWarnings ...

    发一下牢骚和主题无关:

    package anno;

    import java.lang.annotation.Retention;

    import java.lang.annotation.RetentionPolicy;

    @Retention(RetentionPolicy.RUNTIME)

    public @interface MyAnnotation {

    String value();

    }

    package anno;

    import java.lang.annotation.Annotation;

    @MyAnnotation("sss")

    public class AnnotationTest {

    public static void main(String[] args) {

    Annotation[] annotations = AnnotationTest.class.getAnnotations();

    System.out.println(((MyAnnotation)annotations[0]).value());

    }

    }

    打印:sss

    一、java内置注解

    - J0 y. E* ?9 c1 C6 R' t5 Z& l

    0 E( x( H$ S+ Y* @

    1、@Target 表现该注解用于什么地方,可能的 ElemenetType 参数含包:

    ElemenetType.CONSTRUCTOR   构造器声明

    / ^& b9 Z* h. g& Y, t- A+ Y7 [9 \

    ElemenetType.FIELD   域声明(含包 enum 实例)

    ElemenetType.LOCAL_VARIABLE   局部量变声明

    5 O! ?- S3 S0 y" G) z

    ElemenetType.METHOD   方法声明

    ! V! b. V4 f5 X' a/ c, b, ?+ W1 K/ g

    ElemenetType.PACKAGE   包声明

    2 S' f+ P  ?* c+ X

    ElemenetType.PARAMETER   参数声明

    6 s! Q9 J& @! x

    ElemenetType.TYPE   类,接口(含包注解型类)或enum声明

    2、@Retention 表现在什么级别保存该注解信息。可选的 RetentionPolicy 参数含包:

    RetentionPolicy.SOURCE   注解将被编译器抛弃

    4 P' T+ s1 {9 }

    RetentionPolicy.CLASS   注解在class文件中可用,但会被VM抛弃

    RetentionPolicy.RUNTIME   VM将在行运期也留保注释,因此可以通过反射机制取读注解的信息。

    / L1 h" G6 R! D; W/ i

    & s: U6 X& F) e/ m9 F/ Z

    3、@Documented 将此注解含包在 javadoc 中

    H& h3 g# |8 R  U/ b  x

    4、@Inherited 许允类子承继父类中的注解

    ' {5 |# f. y* ~" _0 M* L# L9 D

    5、@Deprecated  表现前当元素是不赞同应用的。

    a3 y, A+ `! n% M" U* g

    6、@Override  表现前当方法是盖覆父类的方法。

    ; X  `- A2 x# Q/ [+ @; }

    7、@SuppressWarnings  表现闭关一些不当的编译器告警信息。

    ava注解是附加在代码中的一些元信息,用于一些具工在编译、行运时行进剖析和应用,起到说明、配置的能功。

    注解不会也不能影响代码的现实逻辑,仅仅起到辅助性的作用。含包在 java.lang.annotation 包中。

    1、元注解

    元注解是指注解的注解。含包  @Retention @Target @Document @Inherited四种。

    1.1、@Retention: 定义注解的留保策略

    @Retention(RetentionPolicy.SOURCE)

    //注解仅存在于码源中,在class字节码文件中不含包

    @Retention(RetentionPolicy.CLASS)

    // 默许的留保策略,注解会在class字节码文件中存在,但行运时法无取得,

    @Retention(RetentionPolicy.RUNTIME)

    // 注解会在class字节码文件中存在,在行运时可以通过反射获失掉

    1.2、@Target:定义注解的作用目标

    其定义的码源为:

    @Documented

    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.ANNOTATION_TYPE)

    public @interface Target {

    ElementType[] value();

    }

    @Target(ElementType.TYPE)   //接口、类、枚举、注解

    @Target(ElementType.FIELD)  // 字段、枚举的量常

    @Target(ElementType.METHOD)  // 方法

    @Target(ElementType.PARAMETER)  // 方法参数

    @Target(ElementType.CONSTRUCTOR)   // 构造函数

    @Target(ElementType.LOCAL_VARIABLE) // 局部量变

    @Target(ElementType.ANNOTATION_TYPE) // 注解

    @Target(ElementType.PACKAGE) / // 包

    由以上的码源可以道知,他的elementType 可以有多个,一个注解可以为类的,方法的,字段的等等

    1.3、@Document:说明该注解将被含包在javadoc中

    1.4、@Inherited:说明类子可以承继父类中的该注解

    2、java 注解的自定义

    面下是自定义注解的一个例子

    @Documented

    @Target({ElementType.TYPE,ElementType.METHOD})

    @Retention(RetentionPolicy.RUNTIME)

    public @interface Yts {

    public enum YtsType{util,entity,service,model};

    public YtsType classType() default YtsType.util;

    }

    @Documented

    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.METHOD)

    @Inherited

    public @interface HelloWorld {

    public String name()default "";

    }

    @Retention(RetentionPolicy.RUNTIME)

    定义的这个注解是注解会在class字节码文件中存在,在行运时可以通过反射获失掉。

    @Target({ElementType.TYPE,ElementType.METHOD})

    因此这个注解可是以类注解,也可是以方法的注解

    这样一个注解就自定义好了,当然注解面里的成员可以为基本的数据型类,也可以为数据,Object等等

    3 注解是定义好了,那么怎么来失掉,剖析注解呢?

    java的反射机制可以帮助,失掉注解,代码如下:

    public class ParseAnnotation {

    public void parseMethod(Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, InstantiationException{

    Object obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{});

    for(Method method : clazz.getDeclaredMethods()){

    HelloWorld say = method.getAnnotation(HelloWorld.class);

    String name = "";

    if(say != null){

    name = say.name();

    method.invoke(obj, name);

    }

    Yts yts = (Yts)method.getAnnotation(Yts.class);

    if(yts != null){

    if(YtsType.util.equals(yts.classType())){

    System.out.println("this is a util method");

    }else{

    System.out.println("this is a other method");

    }

    }

    }

    }

    @SuppressWarnings("unchecked")

    public void parseType(Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{

    Yts yts = (Yts) clazz.getAnnotation(Yts.class);

    if(yts != null){

    if(YtsType.util.equals(yts.classType())){

    System.out.println("this is a util class");

    }else{

    System.out.println("this is a other class");

    }

    }

    }

    }

    前一个方法是剖析失掉方法注解的,后一个方法是失掉类注解的

    以下是测试方法类

    @Yts(classType =YtsType.util)

    public class SayHell {

    @HelloWorld(name = " 小明 ")

    @Yts

    public void sayHello(String name){

    if(name == null || name.equals("")){

    System.out.println("hello world!");

    }else{

    System.out.println(name + "say hello world!");

    }

    }

    }

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, InstantiationException {

    ParseAnnotation parse = new ParseAnnotation();

    parse.parseMethod(SayHell.class);

    parse.parseType(SayHell.class);

    }

    1、Annotation的任务道理:

    JDK5.0中供提了注解的能功,许允开发者定义和应用自己的注解型类。该能功由一个定义注解型类的语法和描述一个注解声明的语法,取读注解的API,一个应用注解修饰的class文件和一个注解处置具工成组。

    Annotation不并直接影响代码的语义,但是他可以被做看是序程的具工或者库类。它会反过来对正在行运的序程语义有所影响。

    Annotation可以冲源文件、class文件或者在行运时通过反射机制多种式方被取读。

    2、@Override注解:

    java.lang

    注释型类 Override

    @Target(value=METHOD)

    @Retention(value=SOURCE)

    public @interface Override

    表现一个方法声明盘算重写类超中的另一个方法声明。如果方法利用此注释型类行进注解但没有重写类超方法,则编译器会成生一条错误消息。

    @Override注解表现类子要重写父类的对应方法。

    Override是一个Marker annotation,用于标识的Annotation,Annotation名称本身表现了要给具工序程的信息。

    面下是一个应用@Override注解的例子:

    class A {

    private String id;

    A(String id){

    this.id = id;

    }

    @Override

    public String toString() {

    return id;

    }

    }

    3、@Deprecated注解:

    java.lang

    注释型类 Deprecated

    @Documented

    @Retention(value=RUNTIME)

    public @interface Deprecated

    用 @Deprecated 注释的序程元素,不励鼓序程员应用这样的元素,常通是因为它很危险或存在更好的择选。在应用不被赞同的序程元素或在不被赞同的代码中行执重写时,编译器会发出告警。

    @Deprecated注解表现方法是不被提议应用的。

    Deprecated是一个Marker annotation。

    面下是一个应用@Deprecated注解的例子:

    class A {

    private String id;

    A(String id){

    this.id = id;

    }

    @Deprecated

    public void execute(){

    System.out.println(id);

    }

    public static void main(String[] args) {

    A a = new A("a123");

    a.execute();

    }

    }

    4、@SuppressWarnings注解:

    java.lang

    注释型类 SuppressWarnings

    @Target(value={TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})

    @Retention(value=SOURCE)

    public @interface SuppressWarnings

    示指应当在注释元素(以及含包在该注释元素中的全部序程元素)中取消示显指定的编译器告警。注意,在给定元素中取消示显的告警集是全部含包元素中取消示显的告警的超集。例如,如果注释一个类来取消示显某个告警,同时注释一个方法来取消示显另一个告警,那么将在此方法中同时取消示显这两个告警。

    根据格风不同,序程员应当一直在最里层的嵌套元素上应用此注释,在那里应用才有效。如果要在特定的方法中取消示显某个告警,则应当注释该方法而不是注释它的类。

    @SuppressWarnings注解表现制抑告警。

    面下是一个应用@SuppressWarnings注解的例子:

    @SuppressWarnings("unchecked")

    public static void main(String[] args) {

    List list = new ArrayList();

    list.add("abc");

    }

    5、自定义注解:

    应用@interface自定义注解时,动自承继了java.lang.annotation.Annotation接口,由编译序程动自实现其他细节。在定义注解时,不能承继其他的注解或接口。

    自定义最简略的注解:

    public @interface MyAnnotation {

    }

    应用自定义注解:

    public class AnnotationTest2 {

    @MyAnnotation

    public void execute(){

    System.out.println("method");

    }

    }

    5.1、添加量变:

    public @interface MyAnnotation {

    String value1();

    }

    应用自定义注解:

    public class AnnotationTest2 {

    @MyAnnotation(value1="abc")

    public void execute(){

    System.out.println("method");

    }

    }

    当注解中应用的属性名为value时,对其赋值时可以不指定属性的名称而直接写上属性值接口;除了value外意的量变名都要需应用name=value的式方赋值。

    5.2、添加默许值:

    public @interface MyAnnotation {

    String value1() default "abc";

    }

    5.3、多量变应用枚举:

    public @interface MyAnnotation {

    String value1() default "abc";

    MyEnum value2() default MyEnum.Sunny;

    }

    enum MyEnum{

    Sunny,Rainy

    }

    应用自定义注解:

    每日一道理

    翻开早已发黄的页张,试着寻找过去所留下的点点滴滴的足迹。多年前的好友似乎现在看来已变得陌生,匆忙之间,让这维持了多年的友谊变淡,找不出什么亲切感,只是偶尔遇上,淡淡地微笑,如今也只能在这发黄的页张中找寻过去的那些让人难忘的,至少我可以握住这仅剩下一段的“丝线头”……

    public class AnnotationTest2 {

    @MyAnnotation(value1="a", value2=MyEnum.Sunny)

    public void execute(){

    System.out.println("method");

    }

    }

    5.4、数组量变:

    public @interface MyAnnotation {

    String[] value1() default "abc";

    }

    应用自定义注解:

    public class AnnotationTest2 {

    @MyAnnotation(value1={"a","b"})

    public void execute(){

    System.out.println("method");

    }

    }

    6、置设注解的作用围范:

    @Documented

    @Retention(value=RUNTIME)

    @Target(value=ANNOTATION_TYPE)

    public @interface Retention

    示指注释型类的注释要留保多久。如果注释型类声明中不存在 Retention 注释,则留保策略默许为 RetentionPolicy.CLASS。

    只有元注释型类直接用于注释时,Target 元注释才有效。如果元注释型类用作另一种注释型类的成员,则无效。

    public enum RetentionPolicy

    extends Enum

    注释留保策略。此枚举型类的量常描述留保注释的不同策略。它们与 Retention 元注释型类一同应用,以指定留保多长的注释。

    CLASS

    编译器将把注释记录在类文件中,但在行运时 VM 不要需留保注释。

    RUNTIME

    编译器将把注释记录在类文件中,在行运时 VM 将留保注释,因此可以反射性地取读。

    SOURCE

    编译器要抛弃的注释。

    @Retention注解可以在定义注解时为编译序程供提注解的留保策略。

    属于CLASS留保策略的注解有@SuppressWarnings,该注解信息不会存储于.class文件。

    6.1、在自定义注解中的应用例子:

    @Retention(RetentionPolicy.CLASS)

    public @interface MyAnnotation {

    String[] value1() default "abc";

    }

    7、应用反射取读RUNTIME留保策略的Annotation信息的例子:

    java.lang.reflect

    接口 AnnotatedElement

    全部已知现实类:

    AccessibleObject, Class, Constructor, Field, Method, Package

    表现前目正在此 VM 中行运的序程的一个已注释元素。该接口许允反射性地取读注释。由此接口中的方法回返的全部注释都是可不变并且可序列化的。调用者可以修改已赋值数组枚举成员的问访器回返的数组;这不会对其他调用者回返的数组发生任何影响。

    如果此接口中的方法回返的注释(直接或间接地)含包一个已赋值的 Class 成员,该成员引用了一个在此 VM 中可不问访的类,则试图通过在回返的注释上调用关相的类回返的方法来取读该类,将致使一个 TypeNotPresentException。

    isAnnotationPresent

    boolean isAnnotationPresent(Class extends Annotation> annotationClass)

    如果指定型类的注释存在于此元素上,则回返 true,否则回返 false。此方法要主是为了便于问访记标注释而计设的。

    参数:

    annotationClass - 对应于注释型类的 Class 象对

    回返:

    如果指定注释型类的注释存在于此象对上,则回返 true,否则回返 false

    抛出:

    NullPointerException - 如果给定的注释类为 null

    从以下版本开始:

    1.5

    getAnnotation

    T getAnnotation(Class annotationClass)

    如果存在该元素的指定型类的注释,则回返这些注释,否则回返 null。

    参数:

    annotationClass - 对应于注释型类的 Class 象对

    回返:

    如果该元素的指定注释型类的注释存在于此象对上,则回返这些注释,否则回返 null

    抛出:

    NullPointerException - 如果给定的注释类为 null

    从以下版本开始:

    1.5

    getAnnotations

    Annotation[] getAnnotations()

    回返此元素上存在的全部注释。(如果此元素没有注释,则回返度长为零的数组。)该方法的调用者可以意随修改回返的数组;这不会对其他调用者回返的数组发生任何影响。

    回返:

    此元素上存在的全部注释

    从以下版本开始:

    1.5

    getDeclaredAnnotations

    Annotation[] getDeclaredAnnotations()

    回返直接存在于此元素上的全部注释。与此接口中的其他方法不同,该方法将疏忽承继的注释。(如果没有注释直接存在于此元素上,则回返度长为零的一个数组。)该方法的调用者可以意随修改回返的数组;这不会对其他调用者回返的数组发生任何影响。

    回返:

    直接存在于此元素上的全部注释

    从以下版本开始:

    1.5

    面下是应用反射取读RUNTIME留保策略的Annotation信息的例子:

    自定义注解:

    @Retention(RetentionPolicy.RUNTIME)

    public @interface MyAnnotation {

    String[] value1() default "abc";

    }

    应用自定义注解:

    public class AnnotationTest2 {

    @MyAnnotation(value1={"a","b"})

    @Deprecated

    public void execute(){

    System.out.println("method");

    }

    }

    取读注解中的信息:

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

    AnnotationTest2 annotationTest2 = new AnnotationTest2();

    //取得AnnotationTest2的Class实例

    Class c = AnnotationTest2.class;

    //取得要需处置的方法Method实例

    Method method = c.getMethod("execute", new Class[]{});

    //判断该方法是不是含包MyAnnotation注解

    if(method.isAnnotationPresent(MyAnnotation.class)){

    //取得该方法的MyAnnotation注解实例

    MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);

    //行执该方法

    method.invoke(annotationTest2, new Object[]{});

    //取得myAnnotation

    String[] value1 = myAnnotation.value1();

    System.out.println(value1[0]);

    }

    //取得方法上的全部注解

    Annotation[] annotations = method.getAnnotations();

    for(Annotation annotation : annotations){

    System.out.println(annotation);

    }

    }

    8、制限注解的应用:

    制限注解应用@Target。

    @Documented

    @Retention(value=RUNTIME)

    @Target(value=ANNOTATION_TYPE)

    public @interface Target

    示指注释型类所用适的序程元素的种类。如果注释型类声明中不存在 Target 元注释,则声明的型类可以用在任一序程元素上。如果存在这样的元注释,则编译器强制实行指定的应用制限。 例如,此元注释示指该声明型类是其自身,即元注释型类。它只能用在注释型类声明上:

    @Target(ElementType.ANNOTATION_TYPE)

    public @interface MetaAnnotationType {

    ...

    }

    此元注释示指该声明型类只可作为庞杂注释型类声明中的成员型类应用。它不能直接用于注释:

    @Target({})

    public @interface MemberType {

    ...

    }

    这是一个编译时错误,它明表一个 ElementType 量常在 Target 注释中涌现了不只一次。例如,以下元注释是法合的:

    @Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD})

    public @interface Bogus {

    ...

    }

    public enum ElementType

    extends Enum

    序程元素型类。此枚举型类的量常供提了 Java 序程中声明的元素的简略分类。

    这些量常与 Target 元注释型类一同应用,以指定在什么情况下应用注释型类是法合的。

    ANNOTATION_TYPE

    注释型类声明

    CONSTRUCTOR

    构造方法声明

    FIELD

    字段声明(含包枚举量常)

    LOCAL_VARIABLE

    局部量变声明

    METHOD

    方法声明

    PACKAGE

    包声明

    PARAMETER

    参数声明

    TYPE

    类、接口(含包注释型类)或枚举声明

    注解的应用制限的例子:

    @Target(ElementType.METHOD)

    public @interface MyAnnotation {

    String[] value1() default "abc";

    }

    9、在帮助档文中参加注解:

    要想在制造JavaDoc文件的同时将注解信息参加到API文件中,可以应用java.lang.annotation.Documented。

    在自定义注解中声明构建注解档文:

    @Documented

    public @interface MyAnnotation {

    String[] value1() default "abc";

    }

    应用自定义注解:

    public class AnnotationTest2 {

    @MyAnnotation(value1={"a","b"})

    public void execute(){

    System.out.println("method");

    }

    }

    10、在注解中应用承继:

    默许情况下注解不并会被承继到类子中,可以在自定义注解时加上java.lang.annotation.Inherited注解声明应用承继。

    @Documented

    @Retention(value=RUNTIME)

    @Target(value=ANNOTATION_TYPE)

    public @interface Inherited

    示指注释型类被动自承继。如果在注释型类声明中存在 Inherited 元注释,并且户用在某一类声明中询查该注释型类,同时该类声明中没有此型类的注释,则将在该类的类超中动自询查该注释型类。此程过会重复行进,直到找到此型类的注释或达到了该类层次结构的顶层 (Object) 为止。如果没有类超有具该型类的注释,则询查将示指前当类没有这样的注释。

    注意,如果应用注释型类注释类外以的任何事物,此元注释型类都是无效的。还要注意,此元注释仅促进从类超承继注释;对已现实接口的注释无效。

    文章结束给大家分享下程序员的一些笑话语录: 现在社会太数字化了,所以最好是有一个集很多功能于一身的设备!

    展开全文
  • 默认注解:@Deprecated @Override ... 自定义注解:public @interface FirstAnno {} #@interface 元注解:加在自定义注解的类接口上 ...@Documented 这个注解可以让生成的文档,有注解注释,默认是没有注解注释
  • java常用注释注解

    2022-05-10 13:40:16
    java常用注释注解
  • 注解注释简介

    2021-11-23 15:25:36
    注解注释是用来解释说明包或者类或者方法甚至某行代码的 用途 的 解释性文字,也可以包含一些基本信息,如作者、时间、参数、功能等。 1.注释方式 1.行注释 标记为 // ,其注释内容从 / / 开始到本行结尾,为比较...
  • IDEA中注解注释快捷键及模板

    千次阅读 2021-09-10 11:25:55
    文章目录单行注释多行注释文档注释(块注释)方法说明注解自动注释新建类作者时间等 单行注释 将光标放置于要注释所在行,使用 Ctrl + /, 添加行注释,再次使用,去掉行注释 若需要将多行进行单行注释,只需要选中要...
  • 下面小编就为大家带来一篇Java 自定义注解及利用反射读取注解的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 注释是不能被解析的。 注解可以被解析。 可以把注解理解为代码里的特殊标记,这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充...
  • php的注释/注解

    2021-11-24 13:58:05
    php中的注解, 分为类注解和属性注解. 用注释来定义类的属性 namespace app\common\model; use think\Model; /*...
  • css 注释_css注解

    2021-06-08 19:08:15
    什么是CSS注解?什么是CSS注释?CSS注释是什么?CSS注解是什么?css注解(css 注解)又被称作CSS注释(css 注释)是有css文件代码间加入注释,...CSS注释教程篇一、CSS注解语法 - TOP在CSS代码中进行注解注释语法:/* 注...
  • IDEA 自定义注解(类注释、方法注释)

    千次阅读 2020-12-07 13:41:39
    文章目录一、生成类注释1、打开设置位置2、将自定义的类注解规则,复制到Class中。3、使用:新建类的时候会自动加上注解二、自定义方法注解1、打开设置2、添加自定义注解模板组3、添加自定义注解模板4、设置模板的...
  • 最近有所了解到自定义注解的应用,因此学习了一下,下面这篇文章主要给大家介绍了关于Java中自定义注解介绍与使用场景的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面来一起看看吧
  • 修改数据库连接和需要生成的表名后,可直接运行生成带中文注释注解的JavaEntity,数据库注释会生成到JavaEntity里
  • 作者avast,源码android-butterknife-zelezny,android-butterknife-zelezny一键生成注解的IDE插件,在Android studio的一个小插件,一键就可以创建布局的注解
  • 文章目录Annotation(注解)的理解常见的Annotation示例自定义 AnnotationJDK 中的元注解 Annotation(注解)的理解 从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持,也就是Annotation(注解)。 Annotation ...
  • 注解--注释注解

    2020-09-27 13:11:31
    注解注释注解 测试类 pro注解解析 测试主方法 package A_Part02.annotation02; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation....
  • 主要介绍了idea注解参数换行时间日期格式设置方法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 注释注解

    2022-07-02 14:46:49
    注释的分类 作用:传递额外的信息,给程序员看,不参与编译Annotation是代码里边的特殊的标记,可以在编译、类加载、运行的时候被读取 ,并执行相应的处理。 2.3 注解的使用 实例化对象不是通过new,而是 属性名=...
  • webStorm自定义注释注解
  • mybatis-comment-generator简介这是用于 中生成注释这一步骤的自定义生成器,默认将数据库注释作为 Java 注释,并支持在生成的 Java 代码中附加注解示例<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,501,689
精华内容 1,400,675
关键字:

注解

友情链接: mengtekaluo.zip