标题：java注释
JAVA注释主要种类
对于Java注释我们主要了解三种： 
1,　// 注释一行
2,　/* ...... */ 注释若干行
3,　/**……*/文档注释
说明
/** ...... */ 注释若干行，并写入 javadoc文档  java图标通常这种注释的多行写法如下： 
/** 
* ......... 
* ......... 
*/ 
javadoc提取注释的工具/**注释内容*/ （其余两种和C++注释一样）. 
注：注释内容即不会被编译的内容，只是解释说明
java注释例子
import java.awt.*; //调用awt包 
import java.applet.*; 
import java.awt.Color; //调用awt中的Color类 
public class extends Applet implements Runnable { 
Image buffer;// 定义图像对象 
Graphics gContext;// 定义图形上下文 
Thread animate;// 定义一个线程 
String s = "这是文字动画"; 
int w, h, x, y, size = 12; // 定义整形变量并赋值 
/** 
* Applet初始化 
* 
* @see java.applet.Applet 
* @return 无 
*/ 
public void init() { 
w = getWidth();// 返回组件的当前宽度。 
h = getHeight();// 返回组件的当前高度。 
buffer = createImage(w, h);// 创建一个宽W高H的图形区域。 （创建一幅用于双缓冲的、可在屏幕外绘制的图像） 
gContext = buffer.getGraphics();// 获得图像使用的图形上下文 
gContext.setColor(Color.blue);// 设置图形上下文的当前颜色为蓝色 
} 
/** 
* Thread 线程启动操作 
*/ 
public void start() { 
// 开始animate线程 
if (animate == null) { 
animate = new Thread(this); 
animate.start(); 
} 
} 
/** 
* Thread 线程终止时的处理操作 以释放资源 
*/ 
public void stop() { 
// 结束animate线程 
if (animate != null) 
animate = null; 
} 
/** 
* Runnable接口的实现 
* 执行所需的操作 
*/ 
public void run() { 
while (true) { 
//X,Y的坐标设定 
x = (w - s.length() * size) / 2; 
y = (h + size) / 2; 
gContext.setFont(new Font("宋体", Font.PLAIN, size)); 
gContext.drawString(s, x, y);//绘制一串字符s内容的文本 
repaint();//重画图形 
try { 
animate.sleep(50);//线程休眠50ms 
} catch (InterruptedException e) {// 捕获异常 
} 
gContext.clearRect(0, 0, w, h);//通过使用当前绘图表面的背景色进行填充来清除指定的矩形.0 - 要清除矩形的x 坐标。0 - 要清除矩形的 y 坐标。w - 要清除矩形的宽度。h - 要清除矩形的高度。 
if (++size > 40) 
size = 12; 
} 
} 
/** 
* Applet画图操作方法 
* 
* @see java.applet.Applet 
*/ 
public void paint(Graphics g) { 
g.drawImage(buffer, 0, 0, this);//绘制指定的buffer的图像 
} 
/** 
* Applet刷新操作，重新绘制图形 
* 
* @see java.applet.Applet 
*/ 
public void update(Graphics g) { 
paint(g);//重新调用paint函数绘制图形 
} 
}
作用
通过注释提高Java源程序代码的可读性；使得Java程序条理清晰，易于区分代码行与注释行。另外通常在程序开头加入作者，时间，版本，要实现的功能等内容注释，方便后来的维护以及程序员的交流。
速算24游戏
规则如下：1、点击“开始游戏”按钮，游戏开始，系统会发出四张牌 
2、并把组合的表达式（四张牌的四则混合运算表达式）输入到输入框里（最终结果=24） 
3、点击“确定”按钮，游戏将会计算你输入的表达式是否正确，并且给出提示 
4、如果输入的表达式不正确，则会让用户重新输入，如果输入的表达式正确，则重新开始游戏猜数字游戏加注释import java.util.Random; 
// 一上来导入包不用说了吧 
public class Caishuzi { 
//服务器端口号8181 
static final int PORT = 8181; 
//声明一个服务器套接字 
ServerSocket serverSocket; 
//客户端套接字 
Socket socket; 
//数据输入流 
DataInputStream netIn; 
//数据输出流 
DataOutputStream netOut; 
//随机数的数组 
int randomNum[]; 
//游戏等级 
int level = 0; 
public Caishuzi() { //猜数字的构造函数 
initRandomNum(); 
waitConnect(); 
} 
private void initRandomNum() {//初始化随机数 
randomNum = new int[5];//数组初始化，大小为5 
Random ran = new Random();//随机数类 
for (int i = 0; i < 5; i++) { 
randomNum[i] = ran.nextInt(100);//生成5个随机数，范围0~99 
} 
} 
// 
private void waitConnect() {//等待客户端连接 
BufferedReader ansiIn = new BufferedReader(new InputStreamReader( 
System.out.println("服务器启动."); 
try { 
serverSocket = new ServerSocket(PORT);//服务器套接字 
System.out.println("等待客户端连接......"); 
socket = serverSocket.accept();//侦听并接受到此套接字的连接,注意这句话会一直运行直到有客户端连上 
System.out.println(" " + socket); 
netIn = new DataInputStream(socket.getInputStream()); 
netOut = new DataOutputStream(socket.getOutputStream());//分别得到客户端的输入输出流，这样就可以Client—Server间相互传递数据了 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
// 
private void processAnswer() {//应答客户端 
try { 
String clientMsg = netIn.readUTF();//取得客户端传过来的字符 
while (!clientMsg.equals("end")) {//不停循环，但如果客户端传过来的字符是"end"，就结束了 
System.out.println("客户端：" + clientMsg); 
System.out.print("生成随机数为" + randomNum); 
int clientInputNum = Integer.parseInt(clientMsg);//把客户端猜的数字转成int型 
if (clientInputNum < 0 || clientInputNum > 100)//小于0或大于100不行哦 
System.out.print("输入超过范围，请输入0~100以内的数字"); 
String serverMsg = " "; 
if (clientInputNum == randomNum[level]) { 
serverMsg = "恭喜你猜对了！"; 
} else if (clientInputNum > randomNum[level]) { 
serverMsg = "您输入太大了！"; 
} else if (clientInputNum < randomNum[level]) { 
serverMsg = "您输入太小了！"; 
} 
//以上为猜的数字和服务器生成的随机数比，究竟是大于小于还是等于呢，把结果设到serverMsg变量 
netOut.writeUTF(serverMsg);//然后把信息传到客户端 
if (serverMsg.equals("end")) { 
return; 
} 
clientMsg = netIn.readUTF();//继续下一次猜数字 
} 
} catch (Exception e) { 
// 
System.out.print("连接关闭或数据处理错误"); 
} 
} 
public static void main(String[] args) { 
Caishuzi s = new Caishuzi(); 
} 
}java模块注释1、源文件注释 
源文件注释采用 /** …… */，在每个源文件的头部要有必要的注释信息，包括：文件名；文件编号；版本号；作者；创建时间；文件描述包括本文件历史修改记录等。中文注释模版： 
/** 
* 文 件 名 : 
* CopyRright 
* 文件编号： 
* 创 建 人： 
* 日 期： 
* 修 改 人： 
* 日 期： 
* 描 述： 
* 版 本 号： 
*/ 
类（模块）注释： 
类（模块）注释采用 /** …… */，在每个类（模块）的头部要有必要的注释信息，包括：工程名；类（模块）编号；命名空间；类可以运行的JDK版本；版本号；作者；创建时间；类（模块）功能描述（如功能、主要算法、内部各部分之间的关系、该类与其类的关系等，必要时还要有一些如特别的软硬件要求等说明）；主要函数或过程清单及本类（模块）历史修改记录等。 
英文注释模版： 
/** 
* CopyRright 
* Project: 
* Module ID: 
* Comments: 
* JDK version used: 
* Namespace: 
* Author： 
* Create Date： 
* Modified By： 
* Modified Date: 
* Why & What is modified 
* Version:
java注解
Annotation(注解)是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的，根据注解参数的个数，我们可以将注解分为：标记注解、单值注解、完整注解三类。它们都不会直接影响到程序的语义，只是作为注解（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注解是否只存在于源代码级，或者它也能在class文件中出现。 
元数据的作用 
如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类： 
编写文档：通过代码里标识的元数据生成文档。 
代码分析：通过代码里标识的元数据对代码进行分析。 
编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查基本内置注解@Override 
Java代码 
packagecom.iwtxokhtd.annotation; 
/** 
* 测试Override注解 
* @authorAdministrator 
* 
*/ 
publicclassOverrideDemoTest { 
//@Override 
publicString tostring(){ 
return"测试注解"; 
} 
} 
@Deprecated的作用是对不应该在使用的方法添加注解，当编程人员使用这些方法时，将会在编译时显示提示信息，它与javadoc里的@deprecated标记有相同的功能，准确的说，它还不如javadoc @deprecated，因为它不支持参数，使用@Deprecated的示例代码示例如下： 
Java代码 
packagecom.iwtxokhtd.annotation; 
/** 
* 测试Deprecated注解 
* @authorAdministrator 
* 
*/ 
publicclassDeprecatedDemoTest { 
publicstaticvoidmain(String[] args) { 
//使用DeprecatedClass里声明被过时的方法 
DeprecatedClass.DeprecatedMethod(); 
} 
} 
classDeprecatedClass{ 
@Deprecated 
publicstaticvoidDeprecatedMethod() { 
} 
} 
@SuppressWarnings,其参数有： 
deprecation，使用了过时的类或方法时的警告 
unchecked，执行了未检查的转换时的警告 
fallthrough，当 Switch 程序块直接通往下一种情况而没有 Break 时的警告 
path，在类路径、源文件路径等中有不存在的路径时的警告 
serial，当在可序列化的类上缺少serialVersionUID 定义时的警告 
finally ，任何 finally 子句不能正常完成时的警告 
all，关于以上所有情况的警告Java代码packagecom.iwtxokhtd.annotation; 
importjava.util.ArrayList; 
importjava.util.List; 
publicclassSuppressWarningsDemoTest { 
publicstaticListlist=newArrayList(); 
@SuppressWarnings("unchecked") 
publicvoidadd(String data){ 
list.add(data);
自定义注解
它类似于新创建一个接口类文件，但为了区分，我们需要将它声明为@interface,如下例： 
Java代码 
packagecom.iwtxokhtd.annotation; 
public@interfaceNewAnnotation { 
} 
使用自定义的注解类型 
Java代码 
packagecom.iwtxokhtd.annotation; 
publicclassAnnotationTest { 
@NewAnnotation 
publicstaticvoidmain(String[] args) { 
} 
} 
为自定义注解添加变量 
Java代码 
packagecom.iwtxokhtd.annotation; 
public@interfaceNewAnnotation { 
String value(); 
} 
Java代码 
publicclassAnnotationTest { 
@NewAnnotation("main method") 
publicstaticvoidmain(String[] args) { 
saying(); 
} 
@NewAnnotation(value = "say method") 
publicstaticvoidsaying() { 
} 
} 
定义一个枚举类型，然后将参数设置为该枚举类型，并赋予默认值 
public@interfaceGreeting { 
publicenumFontColor { 
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") 
publicstaticvoidsayHelloWithDefaultFontColor() { 
} 
// 现在将fontColor改为BLUE 
@Greeting(name = "notdefault", fontColor = Greeting.FontColor.BLUE) 
publicstaticvoidsayHelloWithRedFontColor() { 
}注解的高级应用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; 
//读取注解信息 
publicclassReadAnnotationInfoTest { 
publicstaticvoidmain(String[] args) throwsException { 
// 测试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表示这个方法是重写了父类中的方法，而不是自定义的，所以这个时候编译器会去检查你的方法名是否和父类一样，是否写错了。
以上是不同的概念