java编译注释

A. java 语句如何注释

LZ好，217:C 在子类构造中在第一句隐含super();
218:B 访问有public protect private还有默认的default
219:D
220:A,D 还有以/**开头*/结尾的注释
221:A
222:B 实例化和普通的引用数据类型不同
223:D 任何都可以读写,B是正确的 否则会出现流错误
224:B,D(不肯定)
225:D 11601希望对你有帮助！

B. java注释的自定义

它类似于新创建一个接口类文件，但为了区分，我们需要将它声明为@interface,如下例：
Java代码
packagecom.iwtxokhtd.annotation;
public@interfaceNewAnnotation {
}
使用自定义的注解类型
Java代码
packagecom.iwtxokhtd.annotation;
publicclassAnnotationTest {
@NewAnnotation
publicstaticvoidmain(String[] args) {
}
}
为自定义注解添加变量
Java代码
packagecom.iwtxokhtd.annotation;
public@interfaceAnnotation {
String value();
}
Java代码
publicclassAnnotationTest {
@NewAnnotation(main method)
publicstaticvoidmain(String[] args) {
saying();
}
@NewAnnotation(value = say method)
publicstaticvoidsaying() {
}
}
定义一个枚举类型，然后将参数设置为该枚举类型，并赋予默认值
public@interfaceGreeting {
publicenum FontColor {
BLUE,RED,GREEN
};
String name();
FontColor fontColor()defaultFontColor.RED;
}
这里有两种选择，其实变数也就是在赋予默认值的参数上，我们可以选择使用该默认值，也可以重新设置一个值来替换默认值
Java代码
publicclassAnnotationTest {
@NewAnnotation(main method)
publicstaticvoidmain(String[] args) {
saying();
sayHelloWithDefaultFontColor();
sayHelloWithRedFontColor();
}
@NewAnnotation(say method)
publicstaticvoidsaying() {
}
// 此时的fontColor为默认的RED
@Greeting(name = defaultfontcolor)
() {
}
@Greeting(name = notdefault, fontColor = Greeting.FontColor.BLUE)
() {
} 1.1. 限制注解的使用范围
用@Target指定ElementType属性
Java代码(jdk)
packagejava.lang.annotation;
public enum ElementType {
TYPE,
// 用于类，接口，枚举但不能是注解
FIELD,
// 字段上，包括枚举值
METHOD,
// 方法，不包括构造方法
PARAMETER,
// 方法的参数
CONSTRUCTOR,
//构造方法
LOCAL_VARIABLE,
// 本地变量或catch语句
ANNOTATION_TYPE,
// 注解类型(无数据)
PACKAGE
// Java包
}
1.2. 注解保持性策略
Java代码
//限制注解使用范围
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR})
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
在Java编译器编译时，它会识别在源代码里添加的注解是否还会保留，这就是RetentionPolicy。下面是Java定义的RetentionPolicy枚举：
编译器的处理有三种策略：
将注解保留在编译后的类文件中，并在第一次加载类时读取它
将注解保留在编译后的类文件中，但是在运行时忽略它
按照规定使用注解，但是并不将它保留到编译后的类文件中
Java代码
packagejava.lang.annotation;
public enum RetentionPolicy{
SOURCE,
// 此类型会被编译器丢弃
CLASS,
// 此类型注解会保留在class文件中，但JVM会忽略它
RUNTIME
// 此类型注解会保留在class文件中，JVM会读取它
}
Java代码
//让保持性策略为运行时态，即将注解编码到class文件中，让虚拟机读取
@Retention(RetentionPolicy.RUNTIME)
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
1.3. 文档化功能
Java提供的Documented元注解跟Javadoc的作用是差不多的，其实它存在的好处是开发人员可以定制Javadoc不支持的文档属性，并在开发中应用。它的使用跟前两个也是一样的，简单代码示例如下：
Java代码
//让它定制文档化功能
//使用此注解时必须设置RetentionPolicy为RUNTIME
@Documented
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
1.4. 标注继承
Java代码
//让它允许继承，可作用到子类
@Inherited
public @interface Greeting {
//使用枚举类型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
2. 读取注解信息
属于重点，在系统中用到注解权限时非常有用，可以精确控制权限的粒度
注意：要想使用反射去读取注解，必须将Retention的值选为Runtime
Java代码
packagecom.iwtxokhtd.annotation;
importjava.lang.annotation.Annotation;
importjava.lang.reflect.Method;
//读取注解信息
{
publicstaticvoidmain(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();
// 再遍历所有的注解，打印其基本信息
System.out.println(method.getName());
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 注释有三种：// /* */ /** */ 前两种编译器直接跳过，从来不阅读，第三种编译器是可以看懂的，当你使用javadoc这样的命令时会用到，用来生成API时用的。
注解：这东东完全就是给编译器看的。 比如@Ovrride表示这个方法是重写了父类中的方法，而不是自定义的，所以这个时候编译器会去检查你的方法名是否和父类一样，是否写错了。
以上是不同的概念

C. java源代码编译的时候怎么处理注释部分的

所谓的编译就是把高级的语言翻译成计算机可以识别的机器语言，所以当编译程序编译到注释那段的时候程序也会把它编译成机器码的形似存储在内存里，但是这个机器码并不会执行，如果你学过汇编你就会知道它们的存储空间是不一样的

D. 如何实现自定义Java编译时注解功能

自定义注解，可以应用到反射中，比如自己写个小框架。
如实现实体类某些属性不自动赋值，或者验证某个对象属性完整性等
本人自己用过的验证属性值完整性：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface IgnoreProperty {
}
然后实体类中：
public class TarResearch implements Serializable{

@IgnoreProperty
private static final long serialVersionUID = 1L;

@IgnoreProperty
private Integer researchId;

@IgnoreProperty
private TarUser userId;

private String version;

private String grade;
....
}

然后action类中
// 验证数据完整性

Class<TarResearch > userClass = TarResearch .class;

Field[] field = userClass.getDeclaredFields();

for (int i = 0; i < field.length; i++) {

if (field[i].getAnnotation(IgnoreProperty.class) != null) {

continue;

}

String fie = field[i].getName().substring(0, 1).toUpperCase()

+ field[i].getName().substring(1);

Method method = userClass.getMethod("get" + fie);

Object obj = method.invoke(u);

if (obj == null) {

sendResponseMsg(response, "数据错误");

return null;

}

}

E. Java class文件反编译中的注释有什么作用

注释的内容是java字节码，注释掉是为了防止IDE等工具报语法错误。
出现这个现象的原因是反编译失败了，也就是说反编译不出该方法的源码，为了不让用户误认为这是个空方法，直接将字节码显示出来是个好主意，但是直接将字节码显示出来，IDE等工具是会报语法错误的，这时候以注释的形式来表现我觉得是最好的方式。

F. Java使用注释编译错误

javac HelloWorld.java
java HelloWorld

G. java编译时,注释是否编译

注释有注释//和/*....*/，还有一种注释/**.....，前两种并不被编译，但后一种用javadoc命令可以写进文档中！！！！！！

H. Java 什么是注解及注解原理详细介绍

1、注解是针对Java编译器的说明。

可以给Java包、类型(类、接口、枚举)、构造器、方法、域、参数和局部变量进行注解。Java编译器可以根据指令来解释注解和放弃注解，或者将注解放到编译后的生成的class文件中，运行时可用。

2、注解和注解类型

注解类型是一种特殊的接口类型，注解是注解注解类型的一个实例。

注解类型也有名称和成员，注解中包含的信息采用键值对形式，可以有0个或多个。

3、Java中定义的一些注解：

@Override 告诉编译器这个方法要覆盖一个超类方法，防止程序员覆盖出错。

@Deprecated 这个标识方法或类(接口等类型)过期，警告用户不建议使用。

@SafeVarargs JDK7新增，避免可变参数在使用泛型化时候警告”执行时期无法具体确认参数类型“，当然，也可以用@SuppressWarnings来避免检查，显然后者的抑制的范围更大。

@SuppressWarnings(value={"unchecked"}) 抑制编译警告，应用于类型、构造器、方法、域、参数以及局部变量。 value是类型数组，有效取值为：

all, to suppress all warnings

boxing, to suppress warnings relative to boxing/unboxing operations

cast, to suppress warnings relative to cast operations

dep-ann, to suppress warnings relative to deprecated annotation

deprecation, to suppress warnings relative to deprecation

fallthrough, to suppress warnings relative to missing breaks in switch statements

finally, to suppress warnings relative to finally block that don't return

hiding, to suppress warnings relative to locals that hide variable

incomplete-switch, to suppress warnings relative to missing entries in a switch statement (enum case)

javadoc, to suppress warnings relative to javadoc warnings

nls, to suppress warnings relative to non-nls string literals

null, to suppress warnings relative to null analysis

rawtypes, to suppress warnings relative to usage of raw types

restriction, to suppress warnings relative to usage of discouraged or forbidden references

serial, to suppress warnings relative to missing serialVersionUID field for a serializable class

static-access, to suppress warnings relative to incorrect static access

static-method, to suppress warnings relative to methods that could be declared as static

super, to suppress warnings relative to overriding a method without super invocations

synthetic-access, to suppress warnings relative to unoptimized access from inner classes

unchecked, to suppress warnings relative to unchecked operations

unqualified-field-access, to suppress warnings relative to field access unqualified

unused, to suppress warnings relative to unused code and dead code

4、注解的定义

使用 @interface 关键字声明一个注解

public @interface MyAnnotation1

注解中可以定义属性

String name default “defval”;

value是注解中的特殊属性

注解中定义的属性如果名称为 value， 此属性在使用时可以省写属性名

例如，声明一个注解：

@Retention(RetentionPolicy.RUNTIME)

public @interface MyAnno1 {

String msg();

int value();

}

I. Java编译时注解和运行时注解有什么区别

重写，重载，泛型，分别是在运行时还是编译时执行的

1. 方法重载是在编译时执行的，因为，在编译的时候，如果调用了一个重载的方法，那么编译时必须确定他调用的方法是哪个。如：

当调用evaluate("hello")时候，我们在编译时就可以确定他调用的method #1.

2.
方法的重写是在运行时进行的。这个也常被称为运行时多态的体现。编译器是没有办法知道它调用的到底是那个方法，相反的，只有在jvm执行过程中，才知晓到底是父子类中的哪个方法被调用了当有如下一个接口的时候，我们是无法确定到底是调用父类还是子类的方法

3.
泛型(类型检测)，这个发生在编译时。编译器会在编译时对泛型类型进行检测，并吧他重写成实际的对象类型(非泛型代码)，这样就可以被JVM执行了。这个过程被称为"类型擦除"。

类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。

类型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。类型擦除的主要过程如下：

1). 将所有的泛型参数用其最左边界(最顶级的父类型)类型替换。

2). 移除所有的类型参数。

在编译后变成：

4. 注解。注解即有可能是运行时也有可能是编译时。

如java中的@Override注解就是典型的编译时注解，他会在编译时会检查一些简单的如拼写的错误(与父类方法不相同)等

同样的@Test注解是junit框架的注解，他是一个运行时注解，他可以在运行时动态的配置相关信息如timeout等。

5. 异常。异常即有可能是运行时异常，也有可能是编译时异常。

RuntimeException是一个用于指示编译器不需要检查的异常。RuntimeException
是在jvm运行过程中抛出异常的父类。对于运行时异常是不需要再方法中显示的捕获或者处理的。

已检查的异常是被编译器在编译时候已经检查过的异常，这些异常需要在try/catch块中处理的异常。

6. AOP. Aspects能够在编译时，预编译时以及运行时使用。

1).
编译时：当你拥有源码的时候，AOP编译器(AspectJ编译器)能够编译源码并生成编织后的class。这些编织进入的额外功能是在编译时放进去的。

2). 预编译时：织入过程有时候也叫二进制织入，它是用来织入到哪些已经存在的class文件或者jar中的。

3). 运行时：当被织入的对象已经被加载如jvm中后，可以动态的织入到这些类中一些信息。

7. 继承：继承是编译时执行的，它是静态的。这个过程编译后就已经确定

8. 代理(delegate)：也称动态代理，是在运行时执行。