javadoc 生成帮助文档时，注意以下几点

参考：http://www.w3school.com.cn/tags/tag_pre.asp

javadoc 生成帮助文档时，注意以下几点：

1、函数功能描述的结尾一定要有句号，英文句号或中文句号均可。不然会有方法摘要里会出现后边一大片内容。

2、换行用<p>

3、<pre> 元素可定义预格式化的文本。被包围在 pre 元素中的文本通常会保留空格和换行符。而文本也会呈现为等宽字体。

public class JavadocDemo
{
　　/**
　　 * 这个函数的功能是返回你输入的字符串.
　　 * <p>
　　 * 用法如下：
　　 * <blockquote>
　　 * <pre>
　　 * String str = func("this is a test");
　　 * System.out.println(str);
　　 * </pre></blockquote>
　　 * @param str 输入字符串.
　　 * @return 返回字符串
　　 */
　　public static String func(String str)
　　{
　　　　return str;
　　}
}

生成的帮助文档如下



参考

1、参考java源码的Object类wait()方法

/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object, or
* some other thread interrupts the current thread, or a certain
* amount of real time has elapsed.
* <p>
* This method is similar to the {@code wait} method of one
* argument, but it allows finer control over the amount of time to
* wait for a notification before giving up. The amount of real time,
* measured in nanoseconds, is given by:
* <blockquote>
* <pre>
* 1000000*timeout+nanos</pre></blockquote>
* <p>
* In all other respects, this method does the same thing as the
* method {@link #wait(long)} of one argument. In particular,
* {@code wait(0, 0)} means the same thing as {@code wait(0)}.
* <p>
* The current thread must own this object's monitor. The thread
* releases ownership of this monitor and waits until either of the
* following two conditions has occurred:
* <ul>
* <li>Another thread notifies threads waiting on this object's monitor
*     to wake up either through a call to the {@code notify} method
*     or the {@code notifyAll} method.
* <li>The timeout period, specified by {@code timeout}
*     milliseconds plus {@code nanos} nanoseconds arguments, has
*     elapsed.
* </ul>
* <p>
* The thread then waits until it can re-obtain ownership of the
* monitor and resumes execution.
* <p>
* As in the one argument version, interrupts and spurious wakeups are
* possible, and this method should always be used in a loop:
* <pre>
*     synchronized (obj) {
*         while (<condition does not hold>)
*             obj.wait(timeout, nanos);
*         ... // Perform action appropriate to condition
*     }
* </pre>
* This method should only be called by a thread that is the owner
* of this object's monitor. See the {@code notify} method for a
* description of the ways in which a thread can become the owner of
* a monitor.
*
* @param      timeout   the maximum time to wait in milliseconds.
* @param      nanos      additional time, in nanoseconds range
*                       0-999999.
* @throws  IllegalArgumentException      if the value of timeout is
*                      negative or the value of nanos is
*                      not in the range 0-999999.
* @throws  IllegalMonitorStateException  if the current thread is not
*               the owner of this object's monitor.
* @throws  InterruptedException if any thread interrupted the
*             current thread before or while the current thread
*             was waiting for a notification.  The <i>interrupted
*             status</i> of the current thread is cleared when
*             this exception is thrown.
*/
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}

if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}

if (nanos > 0) {
timeout++;
}

wait(timeout);
}

2、>>Html标签定义<<