Documentation on comments

Are you a Java programmer? yes, then the below snippet of code would fully illustrate how documentation comments are created and the required parameters for that.

/**
* 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:
* 

* 
The Component to draw on
* 
A translation origin for rendering and clipping coordinates
* 
The current clip
* 
The current color
* 
The current font
* 
The current logical pixel operation function (XOR or Paint)
* 
The current XOR alternation color
*     (see setXORMode)
* 
* 

* 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.
* 

* 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.
* 

* 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.
  * 

  * 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
  *                  null
  *
                 
@return          true if the image is completely
  *                  loaded and was painted successfully;
  *                  false 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.
  * 

  * 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();
 }
}