Java注解
Java注解(Annotation)
(1) Annotation(注释)是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。
元数据的作用
如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类：
编写文档：通过代码里标识的元数据生成文档。
代码分析：通过代码里标识的元数据对代码进行分析。
编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。
基本内置注释
@Override
Java代码
1. package com.iwtxokhtd.annotation;
2. /**
3. * 测试Override注解
4. * @author Administrator
5. *
6. */
7. public class OverrideDemoTest {
8.
9. //@Override
10. public String tostring(){
11. return "测试注释";
12. }
13. }
package com.iwtxokhtd.annotation;
/**
* 测试Override注解
* @author Administrator
*
public class OverrideDemoTest {
//@Override
public String tostring(){
return "测试注释";
}
}
@Deprecated的作用是对不应该在使用的方法添加注释，当编程人员使用这些方法时，将会在编译时显示提示信息，它与javadoc里的@deprecated标记有相同的功能，准确的说，它还不如javadoc @deprecated，因为它不支持参数，使用@Deprecated的示例代码示例如下：
Java代码
1. package com.iwtxokhtd.annotation;
2. /**
3. * 测试Deprecated注解
4. * @author Administrator
5. *
6. */
7. public class DeprecatedDemoTest {
8. public static void main(String[] args) {
9. //使用DeprecatedClass里声明被过时的方法
10. DeprecatedClass.DeprecatedMethod();
11. }
12. }
13. class DeprecatedClass{
14. @Deprecated
15. public static void DeprecatedMethod() {
16. }
17. }
package com.iwtxokhtd.annotation;
/**
* 测试Deprecated注解
* @author Administrator
*/
public class DeprecatedDemoTest {
public static void main(String[] args) {
//使用DeprecatedClass里声明被过时的方法
DeprecatedClass.DeprecatedMethod();
}
}
class DeprecatedClass{
@Deprecated
public static void DeprecatedMethod() {
}
}
@SuppressWarnings,其参数有：
deprecation，使用了过时的类或方法时的警告
unchecked，执行了未检查的转换时的警告
fallthrough，当Switch 程序块直接通往下一种情况而没有Break 时的警告path，在类路径、源文件路径等中有不存在的路径时的警告
serial，当在可序列化的类上缺少serialVersionUID 定义时的警告
finally ，任何finally 子句不能正常完成时的警告
all，关于以上所有情况的警告
Java代码
1. package com.iwtxokhtd.annotation;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. public class SuppressWarningsDemoTest {
7.
8. public static List list=new ArrayList();
9. @SuppressWarnings("unchecked")
10. public void add(String data){
11. list.add(data);
12. }
13. }
package com.iwtxokhtd.annotation;
import java.util.ArrayList;
import java.util.List;
public class SuppressWarningsDemoTest {
public static List list=new ArrayList();
@SuppressWarnings("unchecked")
public void add(String data){
list.add(data);
}
}
(2)自定义注释
它类似于新创建一个接口类文件，但为了区分，我们需要将它声明为@interface,如下例：Java代码
1. public @interface NewAnnotation {
2. }
public @interface NewAnnotation {
}
使用自定义的注释类型
Java代码
1. public class AnnotationTest {
2. @NewAnnotation
3. public static void main(String[] args) {
4. }
5. }
public class AnnotationTest {
@NewAnnotation
public static void main(String[] args) {
}
}
为自定义注释添加变量
Java代码
1. public @interface NewAnnotation {
2. String value();
3. }
public @interface NewAnnotation {
String value();
}
Java代码
1. public class AnnotationTest {
2. @NewAnnotation("main method")
3. public static void main(String[] args) {
4. saying();
5. }
6. @NewAnnotation(value = "say method")
7. public static void saying() {
8. }
9. }
public class AnnotationTest {
@NewAnnotation("main method")
public static void main(String[] args) {
saying();
}
@NewAnnotation(value = "say method")
public static void saying() {
}
}
定义一个枚举类型，然后将参数设置为该枚举类型，并赋予默认值
Java代码
1. public @interface Greeting {
2. public enum FontColor{
3. BLUE,RED,GREEN
4. };
5. String name();
6. FontColor fontColor() default FontColor.RED;}
7. }
public @interface Greeting {
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() default FontColor.RED;}
}
这里有两种选择，其实变数也就是在赋予默认值的参数上，我们可以选择使用该默认值，也可以重新设置一个值来替换默认值
Java代码
1. @NewAnnonation("main method")
2. public static void main(String[] args) {
3. saying();
4. sayHelloWithDefaultFontColor();
5. sayHelloWithRedFontColor();
6.
7. }
8. @NewAnnonation("say method")
9. public static void saying(){
10.
11. }
12. //此时的fontColor为默认的RED
13. @Greeting(name="defaultfontcolor")
14. public static void sayHelloWithDefaultFontColor() {
15.
16. }
17. //现在将fontColor改为BLUE
18. @Greeting(name="notdefault",fontColor=Greeting.FontColor.BLUE)
19. public static void sayHelloWithRedFontColor() {
20.
21. }
@NewAnnonation("main method")
public static void main(String[] args) {
saying();
sayHelloWithDefaultFontColor();
sayHelloWithRedFontColor();
}
@NewAnnonation("say method")
public static void saying(){
}
//此时的fontColor为默认的RED
@Greeting(name="defaultfontcolor")
public static void sayHelloWithDefaultFontColor() {
}
//现在将fontColor改为BLUE
@Greeting(name="notdefault",fontColor=Greeting.FontColor.BLUE)
public static void sayHelloWithRedFontColor() {
}
(3)注释的高级应用
限制注释的使用范围
用@Target指定ElementType属性
Java代码
1. package https://www.360docs.net/doc/6314398757.html,ng.annotation;
2. public enum ElementType {
3. TYPE,
4. // 用于类，接口，枚举但不能是注释
5. FIELD,
6. // 字段上，包括枚举值
7. METHOD,
8. // 方法，不包括构造方法
9. PARAMETER,
10. // 方法的参数
11. CONSTRUCTOR,
12. //构造方法
13. LOCAL_V ARIABLE,
14. // 本地变量或catch语句
15. ANNOTATION_TYPE,
16. // 注释类型(无数据)
17. PACKAGE
18. // Java包
19. }
package https://www.360docs.net/doc/6314398757.html,ng.annotation;
public enum ElementType {
TYPE,
// 用于类，接口，枚举但不能是注释FIELD,
// 字段上，包括枚举值
METHOD,
// 方法，不包括构造方法PARAMETER,
// 方法的参数
CONSTRUCTOR,
//构造方法
LOCAL_VARIABLE,
// 本地变量或catch语句
ANNOTA TION_TYPE,
// 注释类型(无数据)
PACKAGE
// Java包
}
注解保持性策略
Java代码
1. //限制注解使用范围
2. @Target({ElementType.METHOD,ElementType.CONSTRUCTOR})
3. public @interface Greeting {
4.
5. //使用枚举类型
6. public enum FontColor{
7. BLUE,RED,GREEN
8. };
9. String name();
10. FontColor fontColor() default FontColor.RED;
11. }
//限制注解使用范围
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR}) public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() default FontColor.RED;
}
在Java编译器编译时，它会识别在源代码里添加的注释是否还会保留，这就是RetentionPolicy。下面是Java定义的RetentionPolicy枚举：
编译器的处理有三种策略：
将注释保留在编译后的类文件中，并在第一次加载类时读取它
将注释保留在编译后的类文件中，但是在运行时忽略它
按照规定使用注释，但是并不将它保留到编译后的类文件中
Java代码
1. package https://www.360docs.net/doc/6314398757.html,ng.annotation;
2. public enum RetentionPolicy {
3. SOURCE,
4. // 此类型会被编译器丢弃
5. CLASS,
6. // 此类型注释会保留在class文件中，但JVM会忽略它
7. RUNTIME
8. // 此类型注释会保留在class文件中，JVM会读取它
9. }
package https://www.360docs.net/doc/6314398757.html,ng.annotation;
public enum RetentionPolicy {
SOURCE,
// 此类型会被编译器丢弃
CLASS,
// 此类型注释会保留在class文件中，但JVM会忽略它
RUNTIME
// 此类型注释会保留在class文件中，JVM会读取它
}
Java代码
1. //让保持性策略为运行时态，即将注解编码到class文件中，让虚拟机读取
2. @Retention(RetentionPolicy.RUNTIME)
3. public @interface Greeting {
4.
5. //使用枚举类型
6. public enum FontColor{
7. BLUE,RED,GREEN
8. };
9. String name();
10. FontColor fontColor() default FontColor.RED;
11. }
//让保持性策略为运行时态，即将注解编码到class文件中，让虚拟机读取
@Retention(RetentionPolicy.RUNTIME)
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() default FontColor.RED;
}
文档化功能
Java提供的Documented元注释跟Javadoc的作用是差不多的，其实它存在的好处是开发人员可以定制Javadoc不支持的文档属性，并在开发中应用。它的使用跟前两个也是一样的，简单代码示例如下：
Java代码
1. //让它定制文档化功能
2. //使用此注解时必须设置RetentionPolicy为RUNTIME
3. @Documented
4. public @interface Greeting {
5.
6. //使用枚举类型
7. public enum FontColor{
8. BLUE,RED,GREEN
9. };
10. String name();
11. FontColor fontColor() default FontColor.RED;
12. }
//让它定制文档化功能
//使用此注解时必须设置RetentionPolicy为RUNTIME @Documented
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() default FontColor.RED;
}
标注继承
Java代码
1. //让它允许继承，可作用到子类
2. @Inherited
3. public @interface Greeting {
4.
5. //使用枚举类型
6. public enum FontColor{
7. BLUE,RED,GREEN
8. };
9. String name();
10. FontColor fontColor() default FontColor.RED;
11. }
//让它允许继承，可作用到子类
@Inherited
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() default FontColor.RED;
}
(4)读取注解信息
属于重点，在系统中用到注解权限时非常有用，可以精确控制权限的粒度
Java代码
1. package com.iwtxokhtd.annotation;
2. import https://www.360docs.net/doc/6314398757.html,ng.annotation.Annotation;
3. import https://www.360docs.net/doc/6314398757.html,ng.reflect.Method;
4.
5. //读取注解信息
6. public class ReadAnnotationInfoTest {
7. public static void main(String[] args)throws Exception {
8. //测试AnnotationTest类，得到此类的类对象
9. Class c=Class.forName("com.iwtxokhtd.annotation.AnnotationTest");
10. //获取该类所有声明的方法
11. Method []methods=c.getDeclaredMethods();
12. //声明注解集合
13. Annotation[] annotations;
14. //遍历所有的方法得到各方法上面的注解信息
15. for(Method method:methods){
16. //获取每个方法上面所声明的所有注解信息
17. annotations=method.getDeclaredAnnotations();
18. //再遍历所有的注解，打印其基本信息
19. for(Annotation an:annotations){
20. System.out.println("方法名为："+method.getName()+" 其上面的注解为："+an.annotationType().getSimpleName());
21. Method []meths=an.annotationType().getDeclaredMethods();
22. //遍历每个注解的所有变量
23. for(Method meth:meths){
24. System.out.println("注解的变量名为："+meth.getName());
25. }
26.
27. }
28. }
29.
30. }
31.
32. }
package com.iwtxokhtd.annotation;
import https://www.360docs.net/doc/6314398757.html,ng.annotation.Annotation;
import https://www.360docs.net/doc/6314398757.html,ng.reflect.Method;
//读取注解信息
public class ReadAnnotationInfoTest {
public static void main(String[] args)throws Exception {
//测试AnnotationTest类，得到此类的类对象
Class c=Class.forName("com.iwtxokhtd.annotation.AnnotationTest");
//获取该类所有声明的方法
Method []methods=c.getDeclaredMethods();
//声明注解集合
Annotation[] annotations;
//遍历所有的方法得到各方法上面的注解信息
for(Method method:methods){
//获取每个方法上面所声明的所有注解信息
annotations=method.getDeclaredAnnotations();
//再遍历所有的注解，打印其基本信息
for(Annotation an:annotations){
System.out.println("方法名为："+method.getName()+" 其上面的注解为："+an.annotationType().getSimpleName());
Method []meths=an.annotationType().getDeclaredMethods();
//遍历每个注解的所有变量
for(Method meth:meths){
System.out.println("注解的变量名为："+meth.getName());
}
}
}
}
}
webservice注解详解
webservice注解详解
javax.jws.WebService 当实现Web Service 时，@WebService 注释标记Java 类；实现Web Service 接口时，标记服务端点接口（SEI）。 要点： ? 实现Web Service 的Java 类必须指定@WebService 或@WebServiceProvider 注释。不能同时提供这两种注释。 此注释适用于客户机/服务器SEI 或JavaBeans 端点的服务器端点实现类。 ? 如果注释通过endpointInterface属性引用了某个SEI，那么还必须使用@WebService 注释来注释该SEI。 ? 请参阅适用于使用@WebService 注释的类的方法的规则，以了解更多信息 ?注释目标：类型 ?属性： - name wsdl:portType的名称。缺省值为Java 类或接口的非限定名称。（字符串）- targetNamespace 指定从Web Service 生成的WSDL 和XML 元素的XML 名称空间。缺省值为从包含该Web Service 的包名映射的名称空间。（字符串） - serviceName 指定Web Service 的服务名称：wsdl:service。缺省值为Java 类的简单名称 + Service。（字符串） - endpointInterface 指定用于定义服务的抽象Web Service 约定的服务端点接口的限定名。如果指定了此限定名，那么会使用该服务端点接口来确定抽象WSDL 约定。（字符串）- portName wsdl:portName。缺省值为https://www.360docs.net/doc/6314398757.html,+Port。（字符串）
Java注解
注解 可以先把注解当成注释来看，注释就是给类的各个组成部分（包、类名、构造器、属性、方法、方法参数，以及局部变量）添加一些解释。 可以先不去管注解是用来干什么的，就把它当成注释来看。注解的格式当然不能与注释相同，注解是需要声明的，声明注解与声明一个接口有些相似。当然Java也有一些内置注解，例如：@Override就是内置注解。 1声明注解 声明注解与声明一个接口相似，它需要使用@interface。一个注解默认为Annotation的 注解还可以带有成员，没有成员的注解叫做标记注解。成员的类型只能是基本类型、枚举类型）、String、基本类型数组、String[]，以及注解和注解数组类型。 其中String表示成员的类型，value()表示成员名称。其中圆括号不能没有，也不能在圆
括号内放参数，它不是一个方法，只是一个成员变量。 注解可以有多个成员，但如果只有一个成员，那么成员名必须为value。这时在设置成
Java还提供了一些元注解，用来控制注解，例如@Retention和@Target： ●@Target：ElementType类型（枚举类型），表示当前注解可以标记什么东西，可选 值为： TYPE：可以标记类、接口、注解类、Enum。 FIELD：可以标记属性。 METHOD：可以标记就去。 PARAMETER：可以标记参数。 CONSTRUCTOR：可以标记构造器。 LOCAL_VARIABLE：可以标记局部变量。 ANNOTATION_TYPE：可以标记注解类声明。
PACKAGE：可以标记包。 ●@Retention：RetentionPolicy类型（枚举类型），表示注解的可保留期限。可选值为： SOURCE：只在源代码中存在，编译后的字节码文件中不保留注解信息。 CLASS：保留到字节码文件中，但类加载器不会加载注解信息到JVM。 RUNTIME：保留到字节码文件中，并在目标类被类加载器加载时，同时加载注解信息到JVM，可以通过反射来获取注解信息。 2访问注解 很多第三方程序或工具都使用了注解完成特殊的任务，例如Spring、Struts等。它们都提供了自己的注解类库。在程序运行时使用反射来获取注解信息。下面我们来使用反射来获取注解信息。
JAVA注解
JAVA注解 1、什么是注解 从JDK5开始提供名为Annotation（注释）的功能，它被定义为JSR-175规范。注释是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value="unchecked")。注释可以附加在package, class, method, field 等上面，相当于给它们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。如果没有外部解析工具等对其加以解析和处理的情况，本身不会对Java的源代码或class文件等产生任何影响，也不会对它们的执行产生任何影响。 2、JDK5内置的基本注释 JDK5内置了一些常用的注释，可以在编译时帮我们捕获部分编译错误，及提示信息，下面介绍下这些注释的用法： a、@Override定义在https://www.360docs.net/doc/6314398757.html,ng.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。例如我们为某类重写toString()方法却写成了tostring()，并且我们为该方法添加了@Override注释，在编译时，会提示错误：方法未覆盖其父类的方法。 b、@Deprecated定义在https://www.360docs.net/doc/6314398757.html,ng.Deprecated中，此注释可用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。 c、@SuppressWarnings定义在https://www.360docs.net/doc/6314398757.html,ng.SuppressWarnings中，用来抑制编译时的警告信息。与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数值都是已经定义好了的，我们选择性的使用就好了，如@SuppressWarnings(value = "unchecked")。 3、自定义注解 Annotation类型使用关键字@interface定义一个注解，Annotation 类型可以被它们自己所标注。Java5.0定义了4个标准的meta-annotation类型，分别是：Target、Retention、Documented、Inherited，它们被用来提供对其它annotation类型作说明。这些类型和它们所支持的类在https://www.360docs.net/doc/6314398757.html,ng.annotation包中可以找到。 @Target的用法：指示注释类型所适用的程序元素的种类。如果注释类型声明中不存在Target 元注释，则声明的类型可以用在任一程序元素上。如果存在这样的元注释，则编译器强制实施指定的使用限制。 @Retention的用法：指示注释类型的注释要保留多久。如果注释类型声明中不存在Retention 注释，则保留策略默认为 RetentionPolicy.CLASS。 @Documented的用法：指示某一类型的注释将通过 javadoc 和类似的默认工具进行文档化。应使用此类型来注释这些类型的声明：其注释会影响由其客户端注释的元素的使用。如果类型声明是用 Documented 来注释的，则其注释将成为注释元素的公共 API 的一部分。Documented是一个没有成员的注释。 @Inherited的用法：指示注释类型自动被子类继承。 Inherited也是一个没有成员的注释。注意，如果使用@Inherited注释类以外的任何事物都是无效的。还要注意，此元注释仅对从超类继承注释有效；对已实现接口的注释无效。
java《注解解析》
Java注解(Annotation) (1) Annotation(注释)是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class 文件中出现。 元数据的作用 如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类： 编写文档：通过代码里标识的元数据生成文档。 代码分析：通过代码里标识的元数据对代码进行分析。 编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。 基本内置注释 @Override
Java代码 1. package com.iwtxokhtd.annotation; 2. /** 3. * 测试Override注解 4. * @author Administrator 5. * 6. */ 7. public class OverrideDemoTest { 8. 9. //@Override 10. public String tostring(){ 11. return "测试注释"; 12. } 13. } package com.iwtxokhtd.annotation; /** * 测试Override注解 * @author Administrator * */
java注释模板
java注解与反射
Java的注解与反射 最近在学jdk1.5的新特性，看到注解部分难以理解，不明白到底有什么用处，但与反射接合起来看，就不难看出它的作用之一：代码分析，即使用反射提取java成分的注解，生成日志，便于查看以分析自己编写的代码。 我们先来看看注解的分类：元注解、自定义注解。 其中，元注解就是“用于注解的注解”，@Target、@Retention、@Documented、@Inherited，这些注解被包含在https://www.360docs.net/doc/6314398757.html,ng.annotation 包中，下面我们简要说明这四种注解的作用，其中的具体参数就靠各位自己去百度了。 @Target用于说明注解所修饰的对象范围，注解可以被用来修饰包、类、接口、成员方法、构造器、成员字段、方法参数、枚举值、Annotation类型;@Retention用于定义该自定义注解被保留的时间长短;@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员；@Inherited 元注解是一个标记注解，如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类（注意： @Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。
java注释测试题
java注释测试题 Java源代码原题，加注释 import java.awt.Canvas; import java.awt.Color; import java.awt.Font; import java.awt.Frame; import java.awt.Graphics; import java.awt.Image; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.event.MouseMotionListener; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import java.util.Arrays; import javax.swing.JApplet; import javax.swing.JFrame; import javax.swing.JPanel; public class Billard4K extends JPanel implements Runnable, MouseListener, MouseMotionListener { // GAME STA TES public final int WAITING_TO_START = 0; public final int WAITING_TO_HIT = 1; public final int MOVING = 2; public final int FINISHING = 3; public int state = 0; // TABLE double hR; double[] tableX; double[] tableY; double[] holesX; double[] holesY; // BALLS public int nballs;
JAVA8-十大新特性详解
JAVA8十大新特性详解 本教程将Java8的新特新逐一列出，并将使用简单的代码示例来指导你如何使用默认接口方法，lambda表达式，方法引用以及多重Annotation，之后你将会学到最新的API上的改进，比如流，函数式接口，Map以及全新的日期API Formula接口在拥有calculate方法之外同时还定义了sqrt方法，实现了Formula接口的子类只需要实现一个calculate方法，默认方法sqrt将在子类上可以直接使用。 文中的formula被实现为一个匿名类的实例，该代码非常容易理解，6行代码实现了计算sqrt(a*100)。在下一节中，我们将会看到实现单方法接口的更简单的做法。
public int compare(String a,String b){ return https://www.360docs.net/doc/6314398757.html,pareTo(a); } }); 只需要给静态方法Collections.sort传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。 看到了吧，代码变得更段且更具有可读性，但是实际上还可以写得更短： 对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点： Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。接下来我们看看lambda表达式还能作出什么更方便的东西来： 三、函数式接口 Lambda表达式是如何在java的类型系统中表示的呢？每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为默认方法不算抽象方法，所以你也可以给你的函数式接口添加默认方法。
java中注解的几大作用
@SuppressWarnings("deprecation")//阻止警告 @HelloAnnotation("当为value属性时，可以省掉属性名和等于号。") public static void main(String[]args)throws Exception{ System.runFinalizersOnExit(true); if(AnnotationTest.class.isAnnotationPresent(HelloAnnotation.class)){ HelloAnnotation helloAnnotation= (HelloAnnotation)AnnotationTest.class.getAnnotation(HelloAnnotation.class); System.out.println("color():"+helloAnnotation.color()); System.out.println("value():"+helloAnnotation.value()); System.out.println("author():"+helloAnnotation.author()); System.out.println("arrayAttr():"+helloAnnotation.arrayAttr().length); System.out.println("annotationAttr():"+helloAnnotation.annotationAttr().value()); System.out.println("classType(): "+helloAnnotation.classType().newInstance().sayHello("hello,ketty")); } } @Deprecated//自定义：备注过时的方法信息 public static void sayHello(){ System.out.println("hello,world"); } }
Java 类注释文档编写方法
Java 类注释文档编写方法 对于Java语言，最体贴的一项设计就是它并没有打算让人们为了写程序而写程序——人们也需要考虑程序的文档化问题。对于程序的文档化，最大的问题莫过于对文档的维护。若文档与代码分离，那么每次改变代码后都要改变文档，这无疑会变成相当麻烦的一件事情。解决的方法看起来似乎很简单：将代码同文档“链接”起来。为达到这个目的，最简单的方法是将所有内容都置于同一个文件。然而，为使一切都整齐划一，还必须使用一种特殊的注释语法，以便标记出特殊的文档；另外还需要一个工具，用于提取这些注释，并按有价值的形式将其展现出来。这些都是Java必须做到的。 1 简介 用于提取注释的工具叫作javadoc。它采用了部分来自Java编译器的技术，查找我们置入程序的特殊注释标记。它不仅提取由这些标记指示的信息，也将毗邻注释的类名或方法名提取出来。这样一来，我们就可用最轻的工作量，生成十分专业的程序文档。 javadoc输出的是一个HTML文件，可用自己的Web浏览器查看。该工具允许我们创建和管理单个源文件，并生动生成有用的文档。由于有了jvadoc，所以我们能够用标准的方法创建文档。而且由于它非常方便，所以我们能轻松获得所有Java库的文档。 2 具体语法 所有javadoc命令都只能出现于“/**”注释中。但和平常一样，注释结束于一个“*/”。主要通过两种方式来使用javadoc：嵌入的HTML，或使用“文档标记”。其中，“文档标记”（Doc tags）是一些以“@”开头的命令，置于注释行的起始处（但前导的“*”会被忽略）。有三种类型的注释文档，它们对应于位于注释后面的元素：类、变量或者方法。也就是说，一个类注释正好位于一个类定义之前；变量注释正好位于变量定义之前；而一个方法定义正好位于一个方法定义的前面。如下面这个简单的例子所示： 注意javadoc只能为public（公共）和protected（受保护）成员处理注释文档。“private”（私有）和“友好”（详见5章）成员的注释会被忽略，我们看不到任何输出（也可以用-private标记包括private成员）。这样做是有道理的，因为只有public和protected成员才可在文件之外使用，这是客户程序员的希望。然而，所有类注释都会包含到输出结果里。
java注释规范总结大全
在软件开发的过程中总是强调注释的规范，但是没有一个具体的标准进行说明，通常都是在代码编写规范中简单的描述几句，不能作为一个代码注释检查的标准和依据，做什么都要有一个依据吗:),现在我特整理了一个《Java的注释规范》，内容来自网络、书籍和自己的实际积累。 JA V A注释规范 版本/状态作者版本日期 1.0 ghc 2008-07-02 一、背景 1、当我们第一次接触某段代码，但又被要求在极短的时间内有效地分析这段代码，我们需要什么样的注释信息？ 2、怎么样避免我们的注释冗长而且凌乱不堪呢？ 3、在多人协同开发、维护的今天，我们需要怎么样的注释来保证高质、高交的进行开发和维护工作呢？ 二、意义 程序中的注释是程序设计者与程序阅读者之间通信的重要手段。应用注释规范对于软件本身和软件开发人员而言尤为重要。并且在流行的敏捷开发思想中已经提出了将注释转为代码的概念。好的注释规范可以尽可能的减少一个软件的维护成本, 并且几乎没有任何一个软件，在其整个生命周期中，均由最初的开发人员来维护。好的注释规范可以改善软件的可读性，可以让开发人员尽快而彻底地理解新的代码。好的注释规范可以最大限度的提高团队开发的合作效率。长期的规范性编码还可以让开发人员养成良好的编码习惯，甚至锻炼出更加严谨的思维能力。 三、注释的原则 1、注释形式统一 在整个应用程序中，使用具有一致的标点和结构的样式来构造注释。如果在其他项目组发现他们的注释规范与这份文档不同，按照他们的规范写代码，不要试图在既成的规范系统中引入新的规范。 2、注释的简洁 内容要简单、明了、含义准确，防止注释的多义性，错误的注释不但无益反而有害。 3、注释的一致性 在写代码之前或者边写代码边写注释，因为以后很可能没有时间来这样做。另外，如果有机会复查已编写的代码，在今天看来很明显的东西六周以后或许就不明显了。通常描述性注释先于代码创建，解释性注释在开发过程中创建，提示性注释在代码完成之后创建。修改代码的同时修改相应的注释，以保证代码与注释的同步。 4、注释的位置 保证注释与其描述的代码相邻，即注释的就近原则。对代码的注释应放在其上方相邻或右方的位置，不可放在下方。避免在代码行的末尾添加注释；行尾注释使代码更难阅读。不过在批注变量声明时，行尾注释是合适的；在这种情况下，将所有行尾注释要对齐。 5、注释的数量 注释必不可少，但也不应过多，在实际的代码规范中，要求注释占程序代码的比例达到20%左右。注释是对代码的“提示”，而不是文档，程序中的注释不可喧宾夺主，注释太多了会让人眼花缭乱，注释的花样要少。不要被动的为写注释而写注释。 6、删除无用注释
java《注解解析》
Java注解(Annotation)
(1) Annotation(注释)是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。 元数据的作用 如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类： 编写文档：通过代码里标识的元数据生成文档。 代码分析：通过代码里标识的元数据对代码进行分析。 编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。 基本内置注释 @Override Java代码 1. package com.iwtxokhtd.annotation; 2. /** 3. * 测试Override注解 4. * @author Administrator 5. * 6. */ 7. public class OverrideDemoTest { 8. 9. //@Override 10. public String tostring(){ 11. return "测试注释"; 12. } 13. } package com.iwtxokhtd.annotation; /** * 测试Override注解 * @author Administrator * */ public class OverrideDemoTest { //@Override
java注释规范
设置注释模板的入口： Window->Preference->Java->Code Style->Code Template 然后展开Comments 节点就是所有需设置注释的元素啦。现就每一个元素逐一介绍： 文件(Files)注释标签： /** * @Project: ${project_name} * @Title: ${file_name} * @Package ${package_name} * @Description: ${todo} * @author jeffshaw jeff_chon@https://www.360docs.net/doc/6314398757.html, * @date ${date} ${time} * @Copyright: ${year} https://www.360docs.net/doc/6314398757.html, Inc. All rights reserved. * @version V1.0 */ 类(Types)注释标签（类的注释）： /** * @ClassName: ${type_name} * @Description: ${todo} * @author jeffshaw jeff_chon@https://www.360docs.net/doc/6314398757.html, * @date ${date} ${time} * * ${tags} */ 字段(Fields)注释标签： /** * @Fields ${field} : ${todo} */ 构造函数标签： /** * Title: * Description:
* ${tags} */ 方法(Constructor & Methods)标签： /** * @Title: ${enclosing_method} * @Description: ${todo} * @param ${tags} 设定文件 * @return ${return_type} 返回类型* @throws */ 覆盖方法(Overriding Methods)标签： /* (非 Javadoc) * Title: ${enclosing_method} * Description: * ${tags} * ${see_to_overridden} */ 代表方法(Delegate Methods)标签： /** * ${tags} * ${see_to_target} */ getter方法标签： /** * @return ${bare_field_name} */
Java中注释使用原则
Java中注释的使用是有原则的 Java提供了3种类型的注释 例如： // this is a single-line comment x = 1; // a single-line comment after code 多行注释(C风格) Java同样提供跨越多行的注释类型。这种类型的注释以紧跟着一个星号的正斜杠开始，并以紧跟着一个正斜杠的星号结束。这种类型注释的开始和结束分界符可以在同一行里也可以在不同的行上。例如：/* This is a c-style comment *//* This is also a c-style comment, spanni ng multiple lines */ 注意：C风格的注释不可以嵌套使用。比如下面的用法： /* A comment looks like /* This is a comment */ blah blah blah */ 上面的用法会造成语法错误，因为Java编译器只把第一个*/ 当做注释来处理。(编译器认为注释在第一个“*/”就结束了)。
你可以在多行注释里嵌入单行注释： /* This is a single-line comment: // a single-line comment */ 以及在单行注释里使用多行注释： // /* this is // a multi-line // comment */ 文档注释 文档注释是一种与多行注释很类似的特殊注释，它可以用来为你的源代码产生外部文档。这种注释以紧跟着两个星号的正斜杠开始，并以紧跟着一个正斜杠的星号结束。例如： /** This is a documentation comment *//** This is also a documentatio n comment */ 这里有一些关于文档注释的重要事情要注意： javadoc文档生成器会把文档注释里的所有文本都添加到一个HTML 段落里。这意味着，在文档注释里的任意文本都会被格式化为一个段落;空格和换行符会被忽略。如果你想要特殊的格式，你必须要在文档注释里使用HTML标签。 如果文档注释以超过两个的星号开始，那么javadoc就认为这些星号是用来在源码里创建一个“框”框住注释的，并忽略多余的星号。例如： 该注释仅保留“This is the start of a method”文本。 javadoc会忽略文档注释里处于行首的星号。例如： 该注释仅保留“This is a doc comment on multiple lines that I want to stand out in source code, looking “neat””文本。
java注解详解
注解(Annotation)简介 Annotation(注解)是JDK5.0及以后版本引入的一个特性。注解是java的一个新的类型（与接口很相似），它与类、接口、枚举是在同一个层次，它们都称作为java的一个类型（TYPE）。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。它的作用非常的多，例如:进行编译检查、生成说明文档、代码分析等。 JDK提供的几个基本注解 a.@SuppressWarnings 该注解的作用是阻止编译器发出某些警告信息。 它可以有以下参数: deprecation：过时的类或方法警告。 unchecked：执行了未检查的转换时警告。 fallthrough：当Switch程序块直接通往下一种情况而没有Break时的警告。 path：在类路径、源文件路径等中有不存在的路径时的警告。 serial：当在可序列化的类上缺少serialVersionUID定义时的警告。 finally：任何finally子句不能完成时的警告。 all：关于以上所有情况的警告。 b.@Deprecated 该注解的作用是标记某个过时的类或方法。 c.@Override 该注解用在方法前面，用来标识该方法是重写父类的某个方法。 元注解 a.@Retention 它是被定义在一个注解类的前面，用来说明该注解的生命周期。 它有以下参数： RetentionPolicy.SOURCE：指定注解只保留在一个源文件当中。 RetentionPolicy.CLASS：指定注解只保留在一个class文件中。 RetentionPolicy.RUNTIME：指定注解可以保留在程序运行期间。 b.@Target 它是被定义在一个注解类的前面，用来说明该注解可以被声明在哪些元素前。 它有以下参数： ElementType.TYPE：说明该注解只能被声明在一个类前。 ElementType.FIELD：说明该注解只能被声明在一个类的字段前。 ElementType.METHOD：说明该注解只能被声明在一个类的方法前。 ElementType.PARAMETER：说明该注解只能被声明在一个方法参数前。
注解整理笔记
注解整理笔记 @是java中的注解。 JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 1@SuppressWarnings("serial") 实体类注解例子 2@Entity 3@Table(name = "T_BASE_ROLE") 5@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region = CacheConstants.HIBERNATE_CACHE_BASE) //jackson标记不生成json对象的属性 4@JsonIgnoreProperties (value = { "hibernateLazyInitializer" , "handler","fieldHandler" ,"resources","users"}) public class Role extends BaseEntity implements Serializable { 6@Id 7@GeneratedV alue(strategy = GenerationType.AUTO) 8@Column(name = "ID") public Long getId() { return id;} @Excel(exportName="记录创建者", exportFieldWidth = 30) protected String createUser; 9@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00") @Column(name = "CREATE_TIME", updatable = false) 10@Temporal(TemporalType.TIMESTAMP) public Date getCreateTime() { return createTime;} 11@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = https://www.360docs.net/doc/6314398757.html,ZY) 12@JoinTable(name = "T_BASE_ROLE_RESOURCE", joinColumns = { @JoinColumn(name = "ROLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "RESOURCE_ID") }) 13@OrderBy("id") public List
java关键字和注解
java关键字详解 abstract：修饰符号，声明抽象方法和抽象类。声明方法时表示该方法只有特征签名，没有具体实现。而是把具体实现留给继承该类的子类，并且抽象类不能直接用new来 实例化对象即使有公共的构造函数 assert：断言，用于定位程序错误。它是一种程序的调试，测试方式 boolean：布尔数据类型，属于基本数据类型，默认情况下boolean的值为false。break:流程控制，用于终止switch或循环语句块。Break终止单循环语句，加上标签后就是终止有标签标记的外层循环。 byte：字节型（8位整型），属于基本数据类型。 case：用于switch语句中标记一个判断分支。和switch的表达式的值进行比较，在相等的情况下执行case语句 catch：标记try异常处理语句的处理代码分支。Try与catch一起用来捕获程序异常char：16位的Unicode编码字符型，属于基本数据类型。 class：用于声明java类。 continue：流程控制，用于跳过本次循环中未完成部分而继续下一次循环。和break类似，可以在continue后加标签来跳过外层循环的本次运行 default：用于switch语句中标记默认的分支。即在所有case语句都不执行是执行该语句do：标记do/while循环的开始，用来声明一个循环，这个循环的结束条件可以通过while 关键字设置 double：双精度浮点数，属于基本数据类型。 else：标记if分支的否定分支。即在if条件不满足的情况下执行该语句 extends：用于标记java类间的继承关系。 final：表明终态性，用于声明不允许被继承的类和不允许被重写的方法和常量。它只能定义一个实体一次，以后不能改变它或继承它。也就是说，一个final修饰的类 不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改 变其初始值。 finally：标记try异常处理语句的无条件执行代码分支。用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。 float：单精度浮点型，属于基本数据类型。 for：标记for循环。 if：标记if分支语句。 implements：表明java类接口间的实现关系，它在类的声明中是可选的，用来指明当前类实现的接口。 import：导入软件包。在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字 instanceof：检测某个对象是否是某个特定类的实例。即用来测试第一个参数的运行时类型是否和第二个参数兼容 int：基本数据类型－32位整型。 interface：声明java接口类型。 long：基本数据类型－长整型。 native：用于声明本地方法－无方法体，通过调用底层代码来实现其功能。它用来声明本
AOP中注解参数详解
AOP编程中注解参数详解 @Pointcut("execution(* transfer(..))") private void anyOldTransfer() {} 切入点指定者的支持 Spring AOP 支持在切入点表达式中使用如下的AspectJ切入点指定者： 1：execution：匹配方法执行的连接点，这是你将会用到的Spring的最主要的切入点指定者。 2：within：限定匹配特定类型的连接点（在使用Spring AOP的时候，在匹配的类型中定义的方法的执行）。 3：this：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中bean reference （Spring AOP 代理）是指定类型的实例。 4： target：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中目标对象（被代理的appolication object）是指定类型的实例。 5： args：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中参数是指定类型的实例。 6： @target：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中执行的对象的类已经有指定类型的注解。 7： @args：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中实际传入参数的运行时类型有指定类型的注解。 8： @within：限定匹配特定的连接点，其中连接点所在类型已指定注解（在使用Spring AOP 的时候，所执行的方法所在类型已指定注解）。 9： @annotation：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中连接点的主题有某种给定的注解 合并切入点表达式 切入点表达式可以使用‘&&', '||' 和 '!'来合并.还可以通过名字来指向切入点表达式。切入点表达式的基本语法 Spring AOP 用户可能会经常使用 execution pointcut designator。执行表达式的格式如下： execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) 除了返回类型模式（上面代码片断中的ret-type-pattern），名字模式和参数模式以外，所有的部分都是可选的。返回类型模式决定了方法的返回类型必须依次匹配一个连接点。