Java代码注释规范(From Sun MicroSystem)

    在软件开发中，文档和代码的管理是很重要的，Java中采用了一个很好JavaDoc机制很好把文档和代码连接了起来。只要你的代码是按照规范写的，那么就可以用Tools来生成如Java API Docs那样的HTML文档，很方便查阅、管理。

        以前写代码很注意代码的风格和注释，但是没有按照具体的规范写，只是按照有些参考书上的样子和自己的想法来写，虽然已经感觉很好了，但是当在Sun的主页上看到这个规范后，自己的一些缺点就暴露出来了。下面就把这个规范上的东西做一个总结：

1. 注释的第一步写是描述，这个对于类、成员、接口、包都是一样的。
2. 注释标记的顺序如下：
   

   * @param       (classes, interfaces, methods and constructors only)
   * @return      (methods only)
   * @exception   (@throws is a synonym added in Javadoc 1.2)
   * @author      (classes and interfaces only, required)
   * @version     (classes and interfaces only, required. Seefootnote 1)
   * @see         
   * @since       
   * @serial      (or @serialField or @serialData)
   * @deprecated  (seeHow and When To Deprecate APIs)
   下面给出一个比较完整的例子：
   /**
   * Graphics is the abstract base class for all graphics contexts
   * which allow an application to draw onto components realized on
   * various devices or onto off-screen images.
   * A Graphics object encapsulates the state information needed
   * for the various rendering operations that Java supports.  This
   * state information includes:
   * <ul>
   * <li>The Component to draw on
   * <li>A translation origin for rendering and clipping coordinates
   * <li>The current clip
   * <li>The current color
   * <li>The current font
   * <li>The current logical pixel operation function (XOR or Paint)
   * <li>The current XOR alternation color
   *     (see <a href="#setXORMode">setXORMode</a>)
   * </ul>
   * <p>
   * Coordinates are infinitely thin and lie between the pixels of the
   * output device.
   * Operations which draw the outline of a figure operate by traversing
   * along the infinitely thin path with a pixel-sized pen that hangs
   * down and to the right of the anchor point on the path.
   * Operations which fill a figure operate by filling the interior
   * of the infinitely thin path.
   * Operations which render horizontal text render the ascending
   * portion of the characters entirely above the baseline coordinate.
   * <p>
   * Some important points to consider are that drawing a figure that
   * covers a given rectangle will occupy one extra row of pixels on
   * the right and bottom edges compared to filling a figure that is
   * bounded by that same rectangle.
   * Also, drawing a horizontal line along the same y coordinate as
   * the baseline of a line of text will draw the line entirely below
   * the text except for any descenders.
   * Both of these properties are due to the pen hanging down and to
   * the right from the path that it traverses.
   * <p>
   * All coordinates which appear as arguments to the methods of this
   * Graphics object are considered relative to the translation origin
   * of this Graphics object prior to the invocation of the method.
   * All rendering operations modify only pixels which lie within the
   * area bounded by both the current clip of the graphics context
   * and the extents of the Component used to create the Graphics object.
   * 
   * @author      Sami Shaio
   * @author      Arthur van Hoff
   * @version     %I%, %G%
   * @since       1.0
   */
   public abstract class Graphics {
   
       /** 
        * Draws as much of the specified image as is currently available
        * with its northwest corner at the specified coordinate (x, y).
        * This method will return immediately in all cases, even if the
        * entire image has not yet been scaled, dithered and converted
        * for the current output device.
        * <p>
        * If the current output representation is not yet complete then
        * the method will return false and the indicated 
        * {@link ImageObserver} object will be notified as the
        * conversion process progresses.
        *
        * @param img       the image to be drawn
        * @param x         the x-coordinate of the northwest corner
        *                  of the destination rectangle in pixels
        * @param y         the y-coordinate of the northwest corner
        *                  of the destination rectangle in pixels
        * @param observer  the image observer to be notified as more
        *                  of the image is converted.  May be 
        *                  <code>null</code>
        * @return          <code>true</code> if the image is completely
        *                  loaded and was painted successfully; 
        *                  <code>false</code> otherwise.
        * @see             Image
        * @see             ImageObserver
        * @since           1.0
        */
       public abstract boolean drawImage(Image img, int x, int y, 
         ImageObserver observer);
   
   
       /**
        * Dispose of the system resources used by this graphics context.
        * The Graphics context cannot be used after being disposed of.
        * While the finalization process of the garbage collector will
        * also dispose of the same system resources, due to the number
        * of Graphics objects that can be created in short time frames
        * it is preferable to manually free the associated resources
        * using this method rather than to rely on a finalization
        * process which may not happen for a long period of time.
        * <p>
        * Graphics objects which are provided as arguments to the paint
        * and update methods of Components are automatically disposed
        * by the system when those methods return.  Programmers should,
        * for efficiency, call the dispose method when finished using
        * a Graphics object only if it was created directly from a
        * Component or another Graphics object.
        *
        * @see       #create(int, int, int, int)
        * @see       #finalize()
        * @see       Component#getGraphics()
        * @see       Component#paint(Graphics)
        * @see       Component#update(Graphics)
        * @since     1.0
        */
       public abstract void dispose();
   
       /**
        * Disposes of this graphics context once it is no longer 
        * referenced.
        *
        * @see       #dispose()
        * @since     1.0
        */
       public void finalize() {
   dispose();
       }
   }

   
   
   

有了上面的例子就可以对Java中的注释大概掌握了，以后的问题就是你在现实的编程中加以运用就可以了。