JDK5.0 Annotation学习笔记

合集下载

annotation用法

annotation用法在软件开发中，注解（annotation）是一种非常重要的技术手段，可以将文档、类别、方法、变量等各种元素与代码结合起来。

通过注解，我们可以更加方便地管理代码，提高代码的可读性和可维护性，并且可以在很大程度上减少错误和漏洞的产生。

在本篇文章中，我们将详细介绍注解的用法，帮助大家更好地理解和运用这一技术。

注解的用法分为以下几步：1. 定义注解类型首先，我们需要定义一个注解类型。

注解类型是通过@interface 关键字来定义的。

例如，下面的代码定义了一个名为@MyAnnotation 的注解：```public @interface MyAnnotation {String value() default "";int id() default 0;boolean enabled() default true;}```在这个注解中，我们定义了三个成员变量：value、id 和enabled。

其中，value 成员变量的类型为 String，id 成员变量的类型为 int，enabled 成员变量的类型为 boolean。

这些成员变量也用了默认的字段值，如果我们没有改变他们，则他们将使用默认值。

2. 使用注解类型在使用注解类型时，我们可以将它们应用于某个类、方法、字段等。

例如，下面的代码演示了如何在一个类上应用 @MyAnnotation 注解：```@MyAnnotation(id = 1, value = "Hello World")public class MyClass {// 类体}```在这个注解中，我们为 id、value 成员变量分别设置了初始值，这些值在注解被应用时被保存在注释中。

3. 读取注解最后，我们可以使用反射机制来读取注解。

例如，下面的代码演示了如何读取 @MyAnnotation 注解：```MyAnnotation annotation =MyClass.class.getAnnotation(MyAnnotation.class);System.out.println("id:" + annotation.id());System.out.println("value:" + annotation.value());System.out.println("enabled:" + annotation.enabled());```在这个例子中，我们使用了 MyClass 类的 getClass() 方法来获取它的 Class 对象。

Annotation(注解)

基本Annotation
使用Annotation时要在其前面增加@符号，并把Annotation 当成一个修饰符使用，用于修饰它支持的程序元素三个基本的Annotation： @Override @Deprecated @SuppressWarnings 注意：这三个基本的Annotation都定义在ng包下
抑制编译程序警告@SuppressWarnings
• • 对编译程序说明某个方法中若有警告讯息，则加以抑制 //关闭整个类里的编译器警告
• @SuppressWarnings（value="unchecked"） • public class SuppressWarningsTest{ • public static void main(String[] args){ • list<String>myList=new ArrayList(); • } • }
总结：@SuppressWarnings上一个有参数的Annotation，使用时必须指明参数，一定要在括号里使用name=value来为该Annotation的成员变量设置值。即抑制的警告种类在参数中指明
自定义Annotation类型
• • • • • 定义新的Annotation类型使用@interface关键字，不定义接口非常相似 //定义一个简单的Annotation类型 public @interface Test{ } 使用Annotation时的语法非常类似于public final这样的修饰符，通常可用于修饰程序中的类、方法、变量、接口等。 //使用@Test修饰类定义 @Test //通常放在第一行； public class Person{ ............. } 默认情况下,Annotation可用于修饰任何程序元素，包括类，接口，方法等 public class Person{ @Test public void say(){ ...................... } }

bean知识点总结

bean知识点总结一、Bean 的概念和作用1.1 Bean 的概念Bean 是 Spring 框架中的一个核心概念，它指的是由 Spring 容器管理的对象。

在 Spring 中，所有的对象都由 Spring 容器来创建、配置和管理，这些对象就被称为 Bean。

1.2 Bean 的作用Bean 在 Spring 框架中扮演着非常重要的角色，它具有以下几种主要作用：1) 控制反转（IoC）：在传统的 Java 开发中，对象之间的依赖关系是由程序猿来硬编码的，而在 Spring 框架中，对象之间的依赖关系由 Spring 容器来管理，程序员只需要配置好Bean，然后让 Spring 容器来创建和管理对象之间的依赖关系。

2) 管理对象的生命周期：Spring 容器负责管理 Bean 的生命周期，它负责创建、初始化、销毁和释放 Bean。

3) 提供依赖注入（DI）：Spring 容器可以通过依赖注入的方式将一个 Bean 注入到另一个Bean 中，这样就可以实现对象之间的解耦。

4) 提供 AOP 支持：Spring 容器可以通过切面（Aspect）的方式实现 AOP，进而实现一些功能的横切关注点的分离和复用。

二、Bean 的配置2.1 配置 Bean 的方式在 Spring 中，配置 Bean 有三种主要的方式：1) XML 配置：通过在 XML 文件中使用 <bean> 标签来配置 Bean。

2) 注解配置：通过在 Java 类中使用注解来配置 Bean。

3) Java 配置：通过在 Java 配置类中使用 @Configuration 注解来配置 Bean。

2.2 Bean 的属性配置在配置 Bean 的时候，可以为 Bean 配置一些属性，这些属性可以通过构造函数、setter 方法或字段注入的方式进行配置。

2.3 Bean 的作用域在 Spring 中，Bean 可以设置不同的作用域，主要有以下几种作用域：1) singleton：单例模式，在整个 Spring 容器中只会存在一个 Bean 实例。

Java中的注解（Annotation）

Java中的注解（Annotation）⽬录结构：contents structure [+]1.2.3.1.2.4.1.2.1.什么是注解⽤⼀个词就可以描述注解，那就是元数据，即⼀种描述数据的数据。

所以，可以说注解就是源代码的元数据。

⽐如，下⾯这段代码：@Overridepublic String toString() {return "This is String Representation of current object.";}上⾯的代码中，我重写了toString()⽅法并使⽤了@Override注解。

但是，即使我不使⽤@Override注解标记代码，程序也能够正常执⾏。

那么，该注解表⽰什么？这么写有什么好处吗？事实上，@Override告诉编译器这个⽅法是⼀个重写⽅法(描述⽅法的元数据)，如果⽗类中不存在该⽅法，编译器便会报错，提⽰该⽅法没有重写⽗类中的⽅法。

如果我不⼩⼼拼写错误，例如将toString()写成了toStrring(){double r}，⽽且我也没有使⽤@Override注解，那程序依然能编译运⾏。

但运⾏结果会和我期望的⼤不相同。

现在我们了解了什么是注解，并且使⽤注解有助于阅读程序。

Annotation是⼀种应⽤于类、⽅法、参数、变量、构造器及包声明中的特殊修饰符。

它是⼀种由JSR-175标准选择⽤来描述元数据的⼀种⼯具。

2.为什么要使⽤注解使⽤Annotation之前(甚⾄在使⽤之后)，XML被⼴泛的应⽤于描述元数据。

不知何时开始⼀些应⽤开发⼈员和架构师发现XML的维护越来越糟糕了。

他们希望使⽤⼀些和代码紧耦合的东西，⽽不是像XML那样和代码是松耦合的(在某些情况下甚⾄是完全分离的)代码描述。

假如你想为应⽤设置很多的常量或参数，这种情况下，XML是⼀个很好的选择，因为它不会同特定的代码相连。

如果你想把某个⽅法声明为服务，那么使⽤Annotation会更好⼀些，因为这种情况下需要注解和⽅法紧密耦合起来，开发⼈员也必须认识到这点。

annotation入门实例

Annotation在java的世界正铺天盖地展开,有空写这一篇简单的annotations的文章,算是关于Annotation入门的文章吧,希望能各位们能抛砖,共同学习......不讲废话了,实践才是硬道理.第一部分:了解一下java1.5起默认的三个annotation类型:一个是@Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。

一个是@Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上.一个是@SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭.如果不清楚上面三个类型的具体用法，各位可以baidu或google一下的,很简单的。

第二部分:讲一下annotation的概念先，再来讲一下怎样设计自己的annotation.首先在jdk自带的ng.annotation包里,打开如下几个源文件:1、源文件Target.javaJava代码@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Target {ElementType[] value();}@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Target {ElementType[] value();}其中的@interface是一个关键字，在设计annotations的时候必须把一个类型定义为@interface，而不能用class或interface关键字(会不会觉得sun有点吝啬,偏偏搞得与interface这么像).2、源文件Retention.javaJava代码@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Retention {RetentionPolicy value();}@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Retention {RetentionPolicy value();}看到这里，大家可能都模糊了,都不知道在说什么，别急，往下看一下.在上面的文件都用到了RetentionPolicy，ElementType这两个字段,你可能就会猜到这是两个java文件.的确，这两个文件的源代码如下：3、源文件RetentionPolicy.javaJava代码public enum RetentionPolicy {SOURCE,CLASS,RUNTIME}public enum RetentionPolicy {SOURCE,CLASS,RUNTIME}这是一个enum类型,共有三个值，分别是SOURCE,CLASS 和 RUNTIME.SOURCE代表的是这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译之后，Annotation的数据就会消失,并不会保留在编译好的.class文件里面。

Java_Annotation详解

第13页页
告知编译程序如何处理@Retention
ng.annotation.Retention型态可以在您定义Annotation型 ng.annotation.Retention型态可以在您定义Annotation型型态可以在您定义Annotation 态时，指示编译程序该如何对待您的自定义的Annotation型态态时，指示编译程序该如何对待您的自定义的Annotation型态 Annotation 预设上编译程序会将Annotation信息留在.class档案中，预设上编译程序会将Annotation信息留在.class档案中，但不被虚拟 Annotation信息留在.class档案中机读取，机读取，而仅用于编译程序或工具程序运行时提供信息
浪曦视频在线

第7页页
标示方法為Deprecated @Deprectated
对编译程序说明某个方法已经不建议使用,即该方法是过时的。对编译程序说明某个方法已经不建议使用,即该方法是过时的。 ng.Deprecated也是個Marker ng.Deprecated也是個Marker annotation 也是個 Deprecated这个名称在告知编译程序， @Deprecated标示的方法是 Deprecated这个名称在告知编译程序，被@Deprecated标示的方法是这个名称在告知编译程序一个不建议被使用的方法
浪曦视频在线

第17页页
告知编译程序如何处理@Retention
定义Annotation时必须设定RetentionPolicy为RUNTIME，定义Annotation时必须设定RetentionPolicy为RUNTIME，也就是可 Annotation时必须设定RetentionPolicy 以在VM中读取Annotation信息以在VM中读取Annotation信息 VM中读取Annotation 参见程序

Annotation注解

一、Annotation究竟是什么？Annotation 提供了一条与程序元素关联任何信息或者任何元数据（metadata）的途径。

从某些方面看，annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。

这些信息被存储在annotation的“name=value”结构对中。

annotation类型是一种接口，能够通过java反射API的方式提供对其信息的访问。

annotation能被用来为某个程序元素（类、方法、成员变量等）关联任何的信息。

需要注意的是，这里存在着一个基本的潜规则：annotaion不能影响程序代码的执行，无论增加、删除annotation，代码都始终如一的执行。

另外，尽管一些annotation通过java的反射api方法在运行时被访问，而java语言解释器在工作时忽略了这些annotation。

正是由于java虚拟机忽略了annotation，导致了annotation类型在代码中是“不起作用”的；只有通过某种配套的工具才会对annotation类型中的信息进行访问和处理。

本文中将涵盖标准的annotation和meta- annotation类型，陪伴这些annotation类型的工具是java编译器（当然要以某种特殊的方式处理它们）。

由于上述原因，annotation在使用时十分简便。

一个本地变量可以被一个以NonNull命名的annotation类型所标注，来作为对这个本地变量不能被赋予null 值的断言。

而我们可以编写与之配套的一个annotation代码分析工具，使用它来对具有前面变量的代码进行解析，并且尝试验证这个断言。

当然这些代码并不必自己编写。

在JDK安装后，在JDK/bin目录中可以找到名为“apt”的工具，它提供了处理annotation的框架：它启动后扫描源代码中的annotation，并调用我们定义好的annotation处理器完成我们所要完成的工作（比如验证前面例子中的断言）。

JAVA学习完整版详细笔记

Java基础知识总结Java基础知识总结写代码：1，明确需求。

我要做什么？2，分析思路。

我要怎么做？1,2,3。

3，确定步骤。

每一个思路部分用到哪些语句，方法，和对象。

4，代码实现。

用具体的java语言代码把思路体现出来。

学习新技术的四点：1，该技术是什么？2，该技术有什么特点(使用注意)：3，该技术怎么使用。

demo4，该技术什么时候用？test。

-----------------------------------------------------------------------------------------------一：java概述：1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言更名为Java；Java的三种技术架构:JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。

2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

环境变量的配置：1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdkpath=%JAVA_HOME%\bin2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。

注解annotation的详细介绍

JDK5内置的基本注释JDK5内置了一些常用的注释，可以在编译时帮我们捕获部分编译错误，及提示信息，下面介绍下这些注释的用法：1、@Override定义在ng.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。

如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。

例如我们为某类重写toString()方法却写成了tostring()，并且我们为该方法添加了@Override注释；代码如下：Java代码1.public class OverrideDemo {2.@Override3.public String tostring() {4. return super.toString();5. }6.}在编译时，会提示以下错误信息：引用OverrideTest.java:4: 方法未覆盖其父类的方法@Override^1 错误2、@Deprecated定义在ng.Deprecated中，此注释可用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。

在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。

使用@Deprecated的示例代码如下：Java代码1.public class DeprecatedDemo {2. public static void main(String[] args) {3. DeprecatedClass.DeprecatedMethod();4. }5.}6.7.class DeprecatedClass {8.@Deprecated9. public static void DeprecatedMethod() {10. // TODO11. }12.}在编译时，会得到以下提示信息：引用注意：DeprecatedDemo.java 使用或覆盖了已过时的 API。

java知识点难点总结

java知识点难点总结Java作为一门流行的编程语言，有着广泛的应用领域和大量的开发者群体。

但是，对于初学者和甚至一些有经验的程序员来说，Java也存在着一些难点和陷阱。

本文将总结一些Java中的难点知识点，帮助读者更好地理解和掌握这门语言。

1. 异常处理Java中的异常处理是一个比较困扰程序员的难点。

在Java中，异常是一种程序运行时遇到的问题，如空指针异常、类找不到异常等。

在实际开发中，异常处理是必不可少的。

Java提供了try-catch-finally语句来处理异常，但是在实际项目中，异常可能会导致复杂的处理逻辑，需要程序员有着一定的经验和技巧来处理。

此外，Java也提供了throws和throw关键字来抛出异常和主动抛出异常，这也是初学者比较容易混淆的地方。

2. 多线程多线程是Java的一大特色，也是一大难点。

在Java中，可以通过继承Thread类或者实现Runnable接口来创建线程，但是线程的并发访问可能导致数据同步问题，需要使用synchronized关键字来解决。

而且在Java中，线程的调度、同步、死锁等问题也常常让程序员头疼。

3. 内存管理Java有自己的内存管理机制，但是并不是所有的程序员都能完全理解和掌握。

尤其是对于垃圾回收机制的工作原理和触发条件，大部分程序员只知道有垃圾回收，但是并不了解具体的内部实现。

了解垃圾回收机制对于程序员来说是非常重要的，可以避免内存泄漏和性能问题。

4. 集合框架Java提供了丰富的集合框架，如List、Set、Map等。

对于初学者来说，可能会感到困惑的是各种集合的使用场景和区别，以及集合框架的实现原理。

比如ArrayList和LinkedList的区别，或者HashMap和TreeMap的选择等。

5. 泛型泛型是Java中比较抽象和难理解的概念之一。

在Java中，泛型是一种参数化类型的概念，可以使得代码更加通用和安全。

但是对于一些初学者来说，可能会感到困惑的是泛型的通配符、类型擦除等问题。

javax.annotation 用法

导言一、javax.annotation 是什么？1. javax.annotation 是Java语言中的一个冠方注解包，提供了一系列用于标记和描述程序元素的注解。

2. 它位于Java标准库中，是Java评台提供的一种标准化的元数据形式，主要用于通过标记信息来提供程序元素的描述或指示。

3. javax.annotation 包含了一些常用的注解，如 Deprecated、PostConstruct、PreDestroy 等，这些注解可以用于在程序中添加元数据，以便于编译器、工具或者运行时环境能够根据这些注解提供的信息来进行一些有用的工作。

二、javax.annotation 的常用注解及用法示例1. Deprecated(1) 用法：Deprecated 注解用于标记已经过时的程序元素。

(2) 示例：```javaDeprecatedpublic class SomeClass {// 已经过时的类}```2. PostConstruct(1) 用法：PostConstruct 注解用于标记在构造函数之后由SpringIoC容器自动调用的方法。

(2) 示例：```javapublic class SomeOtherClass {PostConstructpublic void init() {// 在构造函数之后由Spring IoC容器自动调用的初始化方法 }}```3. PreDestroy(1) 用法：PreDestroy 注解用于标记在Bean销毁之前由Spring IoC容器自动调用的方法。

(2) 示例：```javapubic class AnotherClass {PreDestroypublic void cleanUp() {// 在Bean销毁之前由Spring IoC容器自动调用的清理方法 }}```三、javax.annotation 包的其他常用注解1. Resource(1) 用法：Resource 注解用于标记需要注入的资源，它可以用在字段、方法、构造函数等地方。

java注解的写法

注解（Annotation）是 Java 编程语言中的一项重要功能，它允许开发者为类、方法、字段等元素添加额外的信息。

注解可以用于各种目的，包括文档、配置和元编程。

Java 注解的写法非常简单，只需在元素前加上@ 符号，然后跟上注解的名称即可。

例如，以下代码为 Person 类添加了一个 @ToString 注解：@ToStringpublic class Person {private String name;private int age;// 省略其他代码}当您使用 Java 编译器编译此代码时，编译器将生成一个包含 toString() 方法的Person 类。

toString() 方法将根据 @ToString 注解的配置，将 Person 对象的属性转换为字符串。

Java 注解可以具有参数。

参数用于指定注解的配置。

例如，以下代码为 @ToString 注解添加了一个参数，指定要包含在字符串中的属性：@ToString(includeFields ={"name","age"})public class Person {private String name;private int age;// 省略其他代码}现在，当您使用 Java 编译器编译此代码时，编译器将生成一个包含 toString() 方法的 Person 类。

toString() 方法将只包含 name 和 age 属性的值。

Java 注解还可以具有默认值。

默认值用于指定注解的默认配置。

例如，以下代码为 @ToString 注解添加了一个默认值，指定要包含在字符串中的所有属性：@ToString(includeFields =Field.ALL)public class Person {private String name;private int age;// 省略其他代码}现在，当您使用 Java 编译器编译此代码时，编译器将生成一个包含 toString() 方法的 Person 类。

Annotation注解

Annotation注解注解Annotation(注解)概述从JDK5.0开始, Java增加了对元数据(MetaData)的支持，也就是Annotation(注解)。

Annotation其实就是代码里的特殊标记，它用于替代配置文件，也就是说，传统方式通过配置文件告诉类如何运行，有了注解技术后，开发人员可以通过注解告诉类如何运行。

在Java 技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。

掌握注解技术的要点：如何定义注解。

如何反射注解，并根据反射的注解信息，决定如何去运行类。

了解注解及java提供的几个基本注解@SuppressWarnings：抑制编译器警告。

首先编写一个AnnotationTest类，先通过@SuppressWarnings的应用让大家认识和了解一下注解，通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings("deprecation")。

public class AnnotationTest {@SuppressWarnings("deprecation")public static void main(String[] args) {System.runFinalizersOnExit(true);}}@Deprecated：用于表示某个程序元素(类，方法等)已过时。

接着直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用这个方法。

public class AnnotationTest {@SuppressWarnings("deprecation")public static void main(String[] args) {System.runFinalizersOnExit(true);}@Deprecatedpublic static void sayHello() {System.out.println("hi，李阿昀");}}@Override：限定重写父类方法，该注解只能用于方法。

Java Annotation 手册

Java Annotation 手册前言：在上篇文章《Java Annotation入门》中概要性的介绍了Annotation的定义、使用，范围涵盖较广，但是深度不够。

所以作者在《Java Annotation入门》后，继续整理了Annotation的概念和知识点，与喜欢research的朋友们共享。

阅读提示：文中提到的程序成员或者程序元素是一个概念，指组成程序代码的单元：如类、方法、成员变量。

一、Annotation究竟是什么？Annotation提供了一条与程序元素关联任何信息或者任何元数据（metadata）的途径。

从某些方面看，annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。

这些信息被存储在annotation的“name=value”结构对中。

annotation类型是一种接口，能够通过java反射API的方式提供对其信息的访问。

annotation能被用来为某个程序元素（类、方法、成员变量等）关联任何的信息。

需要注意的是，这里存在着一个基本的潜规则：annotaion不能影响程序代码的执行，无论增加、删除annotation，代码都始终如一的执行。

另外，尽管一些annotation通过java的反射api方法在运行时被访问，而java语言解释器在工作时忽略了这些annotation。

正是由于java虚拟机忽略了annotation，导致了 annotation类型在代码中是“不起作用”的；只有通过某种配套的工具才会对annotation类型中的信息进行访问和处理。

本文中将涵盖标准的annotation和meta-annotation类型，陪伴这些annotation类型的工具是java 编译器（当然要以某种特殊的方式处理它们）。

由于上述原因，annotation在使用时十分简便。

一个本地变量可以被一个以NonNull命名的annotation类型所标注，来作为对这个本地变量不能被赋予null值的断言。

全面解析Java中的注解与注释

全⾯解析Java中的注解与注释注解⼀、什么是 Annotation？（注解 or 注释）Annotation, 准确的翻译应该是 -- 注解。

和注释的作⽤完全不⼀样。

Annotation 是JDK5.0及以后版本引⼊的⼀个特性。

与类、接⼝、枚举是在同⼀个层次，可以成为java 的⼀个类型。

语法是以@ 开头简单来说，注释是程序员对源代码的类，⽅法，属性等做的⼀些记忆或提⽰性描述(⽐如这个⽅法是做什么⽤的)，是给⼈来看的。

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

举个简单的例⼦来看⼀下注解的使⽤和作⽤。

@Override 是⽐较常见的Java 内置注解，它的作⽤就是在编译代码的时候检查⼦类中定义的⽅法是否正确。

package annotation;public abstract class Animal {public abstract void eat();}package annotation;public class Cat extends Animal{@Overridepublic void eat(String food) {}}这⾥在⼦类Cat中 eat ⽅法被注解为覆写⽗类的⽅法，但是却⽐⽗类⽅法多出⼀个参数。

如果是在Eclipse 在编辑的话，直接就会有红⾊叉叉提⽰。

(代码编译会通不过)。

如果去掉@Override的注解的话，编译没问题，但是Cat 中eat⽅法就是这个类的⼀个新的⽅法了，⽽不是从⽗类继承的了。

⼆、常见的Java 内置注解包含@Override ，还有哪些常见的Java内置注解？1. @Deprecated注解为不建议使⽤，可以⽤在⽅法和类上。

基本上这种⽅法和类都是因为升级或性能上⾯的⼀些原因废弃不建议使⽤，但是为了兼容或其他原因，还必须保留。

所以就打上这个注解。

在Java 本⾝的API中就有很多这样的例⼦，⽅法打上了这个注解，进到Source code 会看到替代的新的⽅法是哪个。

java Annotation

第一章Java Annotation学习整理第一节概述关于annotation是什么东西，百度一下会有很多关于它的描述，在这里就不用再copy 了，我们还是以一个示例开始吧，在开始示例之前，我们先来一个小故事。

一：故事有一个不学无术的孩子，整日游手好闲，用时下流行的话来形容我觉得最恰当不过，那就是“吃老一族”，依仗着父母现在还能蹦跶，自己好吃懒做无所事事，有一天突然看到台湾呕像歌星菜10的演唱会海报，此时他就准备让老爸帮他倒腾一张贵宾票观看演出，要知道菜10的演唱会贵宾票那是相当难买了，但是老爸为了成全儿子，还是通过各种渠道想尽办法帮他料理，老爸找到了主办单位，经过一番金钱的沟通，最终人家愿意让他的儿子以贵宾的待遇参加演唱会，可是他儿子还不愿意主动的找到主办方亮出自己的身份，他的意思就是自己一进演出现场就要有服务人员识别自己贵宾的身份（都懒到什么程度了），无奈，经过老爸与主办方的一再思考，最后主办方灵机一动，我们可以给他一张卡，只要他带上这个卡，我们就会认出他来，这个卡就是“败家子”卡，到时候让他戴在胸前，父亲大赞此计甚妙！回家之后就给他儿子说了，当然他儿子也就以败家子贵宾的身份观看了演出，在进站口，检票人员一眼就找见了“败家子”并且经过牌号他刚好是“250”，如此幸运，除了享受贵宾待遇之外他还获得了其他的待遇。

二：实现故事故事讲完了，纯属虚构，现在我们以程序的形式进行一下说明，整个的流程在我们看来就是进检票口然后看演唱会，那么贵宾，以及特殊待遇都属于额外的收获，不用和我们的主程序发生任何关系，现在来实现一下。

定义一个annotationpackage erdefined;import ng.annotation.Documented;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;@Retention(RetentionPolicy.RUNTIME)@Documentedpublic@interface VIPAnnotation {String value();}下面是一个观看演出的代码package erdefined;public class Concert {@VIPAnnotation(250)public void attend(){System.out.println("观看演出......");}}注意我们在atten方法上面添加了我们的注解VIPAnnotation好了，我们再写一个主办方的控制程序package erdefined;import ng.reflect.InvocationTargetException;import ng.reflect.Method;public class Main {public static void main(String[] args) throwsInstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException,SecurityException, NoSuchMethodException {Class<Concert> clazz = Concert.class;Object object = clazz.newInstance();Method method = clazz.getMethod("attend", new Class[]{});//首先都是可以看演出的method.invoke(object, new Object[]{});//如果他是vipif(method.isAnnotationPresent(VIPAnnotation.class)){//获得实现了的标记VIPAnnotation vipAnnotation =method.getAnnotation(VIPAnnotation.class);int sequcence=vipAnnotation.value();System.out.println("享受贵宾待遇....");if(250==sequcence){//看是否为第250号//还可以享受贵宾待遇System.out.println("和演员合影.......");}}}}执行结果如下:观看演出......享受贵宾待遇....和演员合影.......通过上面的示例可以看得出来看演出的类并不知道会有额外功能的存在，在看演出的代码中我们并没有看得到一点点关于额外功能类的引用，但是在程序执行之后我们反倒添加了这样的功能，这样让看演出的类专心的做自己的工作，根本不用去关心其他的事情，剩下的事情有别人去做，例子虽然不大，但是已经有了面向切面AOP的味道，我们将看演出作为一个关注点进行了横切，这就是Annotation在程序中起到的作用。