Directory Structure Description Related Documents Javadoc Doclets Terminology Source File Generated File Document Note Note Source Codes Javadoc Tag Use Tag Local Command Line Parameter File Options Javadoc Options Standard Doculets Provides a simple sample Concentration package document creation package document creation package and classes Document Actual Example Environment ClassPath See --------------------------------------------------------------------------------------------------------------------- ------------------------------------- Structure javadoc [options] [packageFiles] [@ The Files] parameter can be arranged in any order. Options command line options, as specified in this document. To learn a typical usage of the Javadoc option, see the actual example. PackageNames a series of names, separated by spaces, such as java.lang java.lang.reflect java.aw. You must specify each package that you want to create a document. Javadoc does not recursively act on a child. The wildcards are not allowed, such as (*). See example - Create a package SourceFiles a series of source file names, separated by spaces. The source file name can include paths and wildcards such as (*). For example: Button.java /Home/src/java/awt/graphics.java See Example - Establish a file. It is also possible to mix the package and source files, as shown in the documentation of the package and classes. @Files contains one or more files of the package name and source file in any order. Description Javadoc parses the declarations and document comments in the Java source file, and generates the corresponding HTML page (default), describes public classes, protection classes, internal classes, interfaces, constructor, methods, and domains. Javadoc can be run for the entire package, a single source file or both. In the first case, a series of package names are passed to javadoc as a parameter. In the second case, a series of source (.java) file name is transmitted. An example is given in this document. At the time of implementation, Javadoc requires and rely on the Java compiler to complete its work. Javadoc call part of the Javac compilation declaration section, ignores member implementation. It builds a rich internal representation of the class, including class level and "use" relationship, then generate HTML. Javadoc also obtains the documentation provided by the user from the document comment from the source code. In fact, Javadoc runs on the .java source files of the pure STUB file without the method. This means you can create the earliest phase of the API. You can write document comments and run Javadoc before writing any code. The dependent compiler ensures that the HTML output corresponds to actual implementation, which may have implicit (rather than non-disclosed) source code. For example, Javadoc will establish a document that exists in the .class file but default constructor (Section 8.6.7 of Java Language Specification) in the source code. When Javadoc is established its internal document structure, it will load all references. Due to this, Javadoc must find all the references, including boot classes, extensions, and user classes. See How to find classes for more information. In general, the class created must be loaded into an extension or located in the classpath located in Javadoc. Javadoc Doclets can use doclets to customize the contents and formats of Javadoc output. Javadoc has a default "embedded" Doculet, called standard doclet, which generates an HTML-format API document.

Users can modify or extend standard doclets, or write their own doclets to generate HTML, XML, MIF, RTF or any output format you want. Information about doclets and its usage is located in the following locations: Javadoc Doclets -Doclet Command Line Options When you do not use the -Doclet command line option, Javadoc will use the default standard DOCLET. No matter which Doclet used, Javadoc tools have several command line options available. Standard DOCLET also adds an additional command line option set. Both the two options will be introduced in the following options. Related Documents For more information on enhanced features in Javadoc 1.2, see JavaDoc Enhancement. For the answers to the common question, see JavaDoc FAQ for information on Javadoc-related tools and bug solutions. For information on how to write document comments, see How to write document comments for JavaDoc. Terminology In a javadoc environment, some terms have a specific meaning: the generated document is generated by the JavaDoc tool according to the documentation in the documentation in the Java source code. The default generated document is HTML format and is generated by standard DOCLET. The name in the name Java language is usually the name of the package, class, interface, domain, constructor, or method. The name can be fully limited, such as java.lang.String.Equals (java.lang.object), but also partially defined, such as Equals (Object). Class with documents generate all documents and interfaces during Javadoc operation. To generate a document, the source file must be available, and its source file name or package name must be passed to the javadoc command. We also refer to these classes called classes included in Javadoc run, or include classes. Reference class and interfaces in the definition (implementation) of classes and interfaces with documents. Examples of reference include return type, parameter type, forced conversion type, interface, import class, and so on. The classes referenced in document comments (such as @see tags) are not calculated. When Javadoc runs, it loads all the reference classes in the Javadoc boot class and class paths into memory (for the found category that is not found, Javadoc will display "Class Untroven" Warning Information). JavaDoc can get enough information from the class file to determine its existence and its members' full-defined names. The external reference class does not generate a reference class for its document during Javadoc operation. That is, these classes are outside the Javadoc running. The name of the document to these classes is called an external reference or external link. For example, if JavaDoc is run only, any class (such as Object) in java.lang is an external reference class. You can use the -link option link to the external reference class. Source file Javadoc will generate an output according to four different "source" files: Java language source file (.java), package annotation file, outline comment file, and other unprocessed files. The following three types are introduced. The package comment file Each package has its own document comment, saved in its own "source" file, Javadoc will merge it into the generated package page. Normally, any document applicable to the entire package can be included in this comment. To create a package comment file, you must name it as package.html and put it in the package directory in the source tree with .java files. Javadoc will automatically find the file name in this location. Note that this file name is the same for all packages. The content of the package comment file is a big document comment, written in HTML, like all other comments, but there is an exception: Document comments should not include annotation separators / ** and * / or front-end star.

When writing a comment, the first sentence should be an overview of the package, and any title or other text should be inserted between and the first sentence. Can include a package mark; like all document comments, in addition to all tags other than {@link} should be described later. If you add a @see tag, it must be a fully qualified name. When Javadoc is running, it will automatically find the file; if you find it, Javadoc does the following: Copy all the content between the and tags for processing. Process any package tags that exist. Insert the processing after the bottom of the package page it generates, such as a package overview. Copy the first sentence of the package to the top of the package page and the overview page (eg, an overview). Determine the rules used by the statement, the same determination class and members describe the same rules of the first statement. Overview Note File Each application or packet set to establish a document can have its own outline document comment, saved in its own "source" file, Javadoc will merge it into the generated outline page. In this comment, any document is usually available for the entire application or package set. To create an overview comment file, you can name the file as any name you want (usually overview.html) and place it anywhere (usually located in the topmost of the source tree). Note that there are multiple outline comment files for the same source file set to run Javadoc multiple times for different packet sets. For example, if the source file of the java.applet package is included in the C: / User / SRC / Java / Applet directory, you can create an overview annotation file C: /user/src/overview.html. Overview The content of the annotation file is a large document comment, written in HTML, similar to the foregoing packet release file. For details, see description. When writing comments, you have to recirculate, the first sentence should be an overview of the application or packet set, and do not insert the title or any other text between and the first sentence. Overview marks can be included; as in all document comments, all tags other than {@Link} are located after the description. If you add a @see tag, it must be a fully qualified name. When running Javadoc, you can specify an overview annotation file with the -OverView option. This file will then be processed in a similar method similar to the incubation file. Copy all content between the and tags for processing. There is any overview mark. Plug the processed text into the bottom of the generated outline page (eg, an overview). Copy the first sentence of the outline annotation to the top of the overview profile page. Other unprocessed files can also include any other file you want Javadoc to copy to the destination directory in the source file. This usually includes a graphical file, an example Java source file (.java), and class file (.class), and independent HTML files whose content is far exceeding the regular Java source file document. To include unprocessed files, put them in a directory called DOC-FILES, which can be the subdirectory of any package directory. Each package can have a use of this subdirectory. For example, if you want to include button image Button.gif in the Java.awt.Button class document, you can place the file in the / home / user / src / java / awt / doc-files / directory. All links to unprocessed files must be hardcoded because Javadoc does not view these files - it just copies the directory and its entire content to the destination.

For example, the link in the Button.java document comment may be similar as follows: / ** * This button is similar to: * * / generated file default, JavadoC usage standard Doclet generates an HTML format document. The Doclet generates the following types of files (where each HTML "page" corresponds to a separate file). Note that Javadoc generates files with two names: files named with class / interface, and files named without class / interface (such as package-summary.html). The files in the latter group include underscores (to prevent conflicts with file names in the previous group). The basic content page generates a class or interface page (classname.html) generating each class or interface generating its document. Generate a package page (package-summary.html) for each package of its document. Javadoc will include any HTML text provided in the package.html file in the source directory tree. Overview of the entire package (Overview-summary.html). It is the home page of the generated document. Javadoc will include any HTML text provided in the file specified by the -OverView option. (Note that there is no overview page in some cases, see Javadoc Output.) Cross Reference Page The Class Tierature of Overview-Tree.html. To view it, you can click Overview on the Navigation Bar and click Tree. The class hierarchy page of the entire package (package-tree.html). To view it, go to a specific package, class or interface page; click Tree to display the hierarchy of the package. The "package-use.html) of each package and a separate page of each class and interface (Class-use / classname.html). This page describes packages, classes, methods, constructor, and domains of any part of the given class, interface, or packet. A class or interface A, the "Usage" page includes a subclass of A, declares a domain of A, a method of returning A, and a method and constructor having a type A parameter. To access the page, you can first go to the package, class, or interface, and then click the Usage link in the navigation bar. Do not encourage the use of the API page (Deprecated-list.html) listing all the names that do not encourage use. (Usually due to improvement, it is not recommended to use the name that does not encourage use, and provides an alternative name. The API that does not encourage the use of the API may be deleted in the future implementation.) Serialized-form.html provides Information which can be sequentially or optically chemically. Each such class has a description of its serialization domain and method. This information is generally not interested in developers using APIs. Although there is no link in the navigation bar, it can be obtained by moving to any serialization class and clicking "Sequenified Form" in the "Refer to" section of the class. Index (INDEX - *. HTML) of all classes, interfaces, constructors, domains, and methods are arranged in alphabetical order. It has internationalized for Unicode and can generate a single file or generate a separate file for each start character (such as A-Z in English). Support file help pages (Help-Doc.html), which describes navigation bar and the above pages. You can use -HelpFile to override the default help file with your own custom help file.

Index.html file creates the HTML framework for display. Loading this file can be displayed with a framework. The file itself does not contain text content. Several frame files (* -frame.html) containing packets, classes, and interface lists are used when displaying the HTML framework. Package-list uses with the -link and -linkoffline option. It is a text file, not an HTML file, and cannot arrive with any link. Stylesheet.css, which is used to control the number, font, font size, font styles, and positioning of the generated page. The HTML framework Javadoc will generate two or three HTML frames, as shown in the figure below. When the source file (* .java) or a single package name is passed to the javadoc command, it will only create a frame (C)-class list in the left bar. When two or more package names are passed to Javadoc, it will create a third framework (P) (all packages) and an overview page (Detail). You can get wrap the frame by clicking or in Overview-Summary.html by "no frame" link. If you are not familiar with the HTML framework, you should remember that the frame can have focus to print or scroll. To make the frame with focus, you can click on it. Then in many browsers, the arrow keys and the flip button will scroll the framework, and the print menu command will print it. ------------ -------------- | C | Detail | | P | Detail | | | | | | | | | | C | | | | | | | | | | ------------ ------------ Javadoc * .java javadoc java.lang java. AWT Depending on whether you want the HTML framework, AWT can load one of the following two files as the start page: Index.html (requires a frame) Overview-summary.html class and interface to generate the file structure generated by the file structure to generate with Java Source Documentation hierarchical organizations as files and class files. This structure is a directory for each sub-package. For example, the document generated for java.applet.applet class will be located in Java / Applet / Applet.html. The file structure of the Java.applet package is also the same, assume that the destination directory is named APIDOCS. As mentioned earlier, all files containing the word "frame" will appear in the upper left frame or the lower left frame. All other HTML files appear in the right frame. Note - the directory is displayed in bold. The asterisk (*) indicates the files and directories that the Javadoc parameters are the source file (* .java) instead of the package name.

In addition, when the parameter is the source file name, Package-List will be created but it is empty. The document file directory will not appear in the destination unless it exists in the source record tree. Apidocs Top Catalog Index.html Established an initial page of the HTML frame * Overview-summary.html Lists all packages with the first sentence overview-tree.html List all packets class level deprecated-list.html lists all packets Un encouraised API serialized-form.html lists all packages * overview-frame.html lists all packets, used for all classes of all packages AllClasses-frame.html, for the left frame Help-doc.html lists how to organize users of these pages Help index-all.html The default indexed index-file created with the -SplitIndex option is created with the -splitIndex options Index- .html with -splitIndex Option Create Index File Package-List lists the package name, only for parsing the external reference Stylesheet.css HTML style form, used to define font, color, and location Java sub-package catalog Applet sub-package directory applet.html Applet class AppletContext. HTML AppletContext interface page AppletStub.html AppletStub interface page Audioclip.html AudioClip interface page * Package-summary.html Lists class * package-frame.html with the first quarter * package-frame.html lists the classes in the package, using the lower left frame * package-tree.html lists the class hierarchial package-use listing the package Use the local DOC-FILES for this package to save images and sample files CLASS-USE Save API Pages Contents Applet.html Applet Category AppletContext.html AppletContext Interface Page AppletStub.html AppletStub Interface Page Audioclip.html AudioClip interface Using the Method Document Note Note source code can include document comments in front of any entity (class, interface, method, constructor, or domain) declaration in the source code. They are also known as Javadoc comments, and files must be written with HTML, they should use HTML entities and use HTML tags.

Users can use any HTML versions supported by their own browser; the standard DOClet we have written can generate HTML 3.2-compatible code outside of other places, including cascading style forms and frames (due to the use of frame sets, we are in every "HTML 4.0" is added in front of the generated file). For example, an entity less than (<) and greater than (>) symbols should be written as . Similarly, with symbols (&) should be written as &. Bold HTML tag is shown in the example below. Below is a document comment: / ** * This is DOC comment. * @See java.lang.Object * / Document Note Composition of characters between the character / ** of the start comment and the character * / end annotation. The text is divided into one or more lines. When Javadoc parsing document comments, the leader asterisk (*) in each row will be removed; the space and tabular characters in front of the initial asterisk (*) are also discarded. If you omit a row, all front guides will be removed. (To a certain extent, the front star number can be ignored. Due to the case of the problem of the problem of the predetermodium, the problem is used to format the indentation of the multi-line indentation, such as the sample code. There is no avatar, The indentation in the generation document will be lost because the preamble space is deleted.) The first sentence of each document comment should be an overview name, including the complete brief description of the declared entity. The statement ends with spaces, tabulation or row ends, or ends at the first tag at the end of the first period. Javadoc copies the first sentence to the member overview of the top of the HTML page. Document Note Only in front of the class, interface, constructor, method, or domain declaration can be identified. Each statement has only one document comment as the Javadoc tool identifies. When embedding an HTML tag in a document comment, the HTML title tag should not be used, for example,

and

, because Javadoc creates a fully structured document, and these tags will interfere with the format of the generated document. The first line document comment starting with character @ will end the description and start the marker paragraph. The @see tag in the above example is this tag passage. For specifications for document comments, see Chapter 18, "Document Notes" in JAMES GOSLING, BILL JOY, and Guy Stele. Javadoc tag Javadoc parses special tags embedded in the Java document comment. These document marks help automatically generate a complete format API from the source code. The tag begins with "AT" symbol (@) and can't case sensitive - you must enter the alphabet by correct case. The tag must start from the beginning of a row (after any preamble space and optional asterisk), otherwise it will be considered a normal text. Put the same name marked as required. For example, put all @see tagged together. For information about the markers we will introduce in future versions, see the proposed tag.

The current markup: marker introduced the JDK version @Author 1.0 @Deprecated 1.0 @Exception 1.0 {@Link} 1.0 @see 1.0 @serial 1.2 @serialData 1.2 @serialfield 1.2 @since 1.1 @throws 1.2 @ Version 1.0 @Author Name-text When using the -author option, add an "Author" item in the generated document with the specified Name-text. Document comments can contain multiple @Author tags. You can specify one or more names for each @Author. In the previous case, Javadoc will insert a comma (,) and spaces between the names. In the latter case, all text is copied to the generated document without parsing. If you want to use a localized name separator other than a comma, you should use this name per line. @DEPRECated DepRecated-text Add a comment, indicating that the API should not be used again (although it is still available). Javadoc moves deprecated-text to the front of the description, display with italics, and adds bold warnings in front of it: "Do not encourage". The first sentence of deprecated-text should at least tell the user to start without encouraging the use of the API and uses what to replace it. Javadoc only copies the first sentence to the overview section and the index. The following statement can also explain why it does not encourage it. A {@link} tag pointing to an alternate API (for javadoc 1.2 or update): For JavaDoc 1.2, use {@link} tag. This will create an inline link in the required place. For example: / ** * @DepRecated is replaced by {@link #setbounds (int, int, int, int)} in JDK 1.1. * / For Javadoc 1.1, the standard format is to create @see tags for each @DepRecated tag (it can't be embedded). See the @DepRecated tag for information that does not encourage use. @Exception Class-Name Description @Exception tag is the synonym of @throws. {@LINK Name Label} Insert the inline link to the specified NAME. The syntax of Name and Label is identical to the @see tag, but it produces a link in the "See" section as described below, but it is placed in the "See" section. This tag begins with curly brackets and ends with curly brackets to distinguish it from other embedded text. If you need to use "}" in the tag, use the HTML entity representation} There is no limit to the number of {@LINK} tags allowed in a statement. This tag can be used in the text section of the document annotation or any tag (eg, @ Deprecated, @ Return or @param). For example, the following is a comment for reference to a getComponentat (int, int) method: using {@Link #getComponentat (int, int) getcomponentat) method.

Depending on it, the standard DOCLET will generate the following HTML (assuming it references the other class in the same package): Use the GetComponentat method. It is displayed on the web page: using the getComponentat method. @Param Parameter-Name Description Adds parameters to the Parameter section. The description can continue to the next line. @Return Description Adds the "Return" section with Description text. This text should describe the value of the return type and allowable range. @see Reference Adds the "See" title, which is a link or text item that points to Reference. Document comments can contain any number of @see tags, which are grouped under the same title. The @see tag has three variants; the third form below is the most common form. @see "string" Note - this form is useless in JDK 1.2. It does not print the reference text. Add a text item for String. Do not create a link. String is a book or other information not available through this URL. Javadoc distinguishes it with the previous situation by looking up the first character as a double quotation number ("). For example: @see" Java Programming Language "This will generate the following text: See:" Java Programming Language @see Label Add a link to the URL # value defined. The URL # value is the relative URL or absolute URL.javadoc distinguishes it with other situations by looking up the first character. For example, : @See Java specification This will generate the following link: see: java spec @see package.class # MEMBER Label Add a link with visible text Label, point to Java The documentation of the name in the language is available. Label is optional; if omitted, the name will appear as visible text, and embed in the HTML tag. When you want to abbreviate the visible text or different from the visible text than the name, You can use label.package.class # Member is any valid name of the Java language - package name, class name, interface name, constructor name, method name, or domain name - in addition to the Hash character (#) replaces the member name. Outside the point. If the name is in a class with a document, Javadoc will automatically create it to its link. To create a link to an external reference class, use the -link option. Use another @see form in any one Quote Uncommon. The first parameter will be described in detail in the specified name. Label is an optional text, which is a visible label. Label can contain spaces. If Label is omitted, Package.class will be displayed. .member, and appropriately shorten relative to the current class and bags. See how to display the name. Space is the delimiter between package.class # member and label. The space in parentheses does not represent the start of the label, so each parameter is in the method Spaces can be used. Example - In this example, the @see tag in the Character class references the equals method in the String class.

This tag includes two parameters: name "String # equals (object)" and tag "equals". . / ** * @see string # equals (object) Equals * / standard DOCLET will produce the following HTML document:

See:

equals It looks like the following in the browser, where the tag is visible link text: see: Equals Specifies the name - package.class # Member name can be fully limited, such as java.lang.string # toppercase (), or not fully limited, such as String # TouPpercase () or #tOrthPercase (). If it is not fully limited, Javadoc uses the normal Java compiler to search for it, and will be further introduced in @see's search order. The name can contain spaces in parentheses, such as between the method parameters. Of course, the advantage of using a shorter "partial defined" name is to type fewer, and less chaotic in the source code. The following table shows the different names of the name, where the Class can be class or interface, Type can be class, interface, array, or basic data type, while Method can be a method or constructor. @see package.class # MEMBER's typical form references the current class member @see # field @ See #method (Type, Type, ...) @ See #Method (Type Argname, Type Argname, ...) Reference Current Package Or other class @see class # field @ See class # method (type, type, ...) @ See class # method (Type Argname, Type Argname, ...) @ See class references other packages (full Limited) @see package.class#field@see package.class # method (type, type, ...) @ See package.class # method (Type Argname, Type Argname, ...) @ See package.class@see Package The following description is applicable to the above table: The first set of forms (without classes) will cause JavadoC only search for the current class level. It will look for the current class or interface, its parent class, or hyper interface, or it contains a member of the class or interface (Search Step 1-3). It does not search for the rest of the current package or other packages (search steps 4-5). If any method or constructor is input to a name without parentheses, such as getValue, and if there is no domain with the same name, Javadoc will correctly create a link, but will display a warning message, prompt to add parentheses and parameters. If the method is overloaded, Javadoc will link to the first unspecified method it searched. For all forms, the internal class must be specified as Outer.inner, not a simple Inner. As mentioned above, the HASH character (#) is not a point (.) For separation classes and members. This makes javadoc to correctly parse because points are also used to separate classes, internal classes, packages, and subclats.

When the Hash character (#) is the first character, it is absolutely indispensable. However, in other cases, JavadoC is usually not strict and allows usage numbers when not generating ambiguity, but it will display a warning. @See search order - Javadoc will process the @see tag in the source file (.java), package file (package.html) or overview.html. In the latter two files, you must fully qualify the name provided by @see. In the source file, you can specify a fully qualified or partially qualified name. When Javadoc encounters the @see tag in .java, it searches for the same order as the Java compiler (Javadoc will not detect the namespace between the namespace, because it assumes that the source code does not have these errors Searching order is formally defined in the "Name" in the Java Language Specification, modified by "Internal Class Specification". Javadoc searches for this name in all relevant and import classes and packets. In particular, it searches as follows: Class or interface contains classes and interfaces, first search for the nearest parent class and overport, first search for the nearest current package any import package, class, and interface, press the order in the introduction statement Search Javadoc continues to repeat step 1-3 of each class it encounter until a match is found. That is to say, when it searches for the current class and it contains class E, it searches for the parent class of e before searching E. In steps 4 and 5, JavaDoc does not press any specified order (the order depends on the specific compiler) search the class or interface in the package. In step 5, Javadoc will look for in in java.lang because it is automatically imported by all programs. Javadoc does not need to find in subclasses, and there is no need to find in other packages, even if their documents are generated in the same run. For example, if the @see tag is in the java.awt.event.keyevent class and reference the name in the java.awt package, Javadoc will not find the package unless the class imports it. If the name is displayed - if Label is omitted, package.class.member will be displayed. Generally, it will be properly shortened relative to the current class and packages. Here "shortened" means only the necessary names and make it as short as possible. For example: Method includes @see tag @see tags to display as string.touppercase () @see string # @see string # toLowercase () () TOLOWERCASE () () @see charactercase () @see charactercase () @see charactercase () @see character # Toolcase CHAR) (Reference Other Class Members) Character.tolowerCase (Char) (including class name) @see examples The comment on the right side displays how to display the name when the @see tag is in other packages (such as java.applet.applet).

See: @see java.lang.string // string @see java.lang.string the string class // String @see string # equals (objetc) // string.equals (object) @see String # equals // string.equals (java.lang.object) @see java.lang.Object # wait (long) // java.lang.object.wait (long) @see character # max_Radix // character.max_radix @ See Java Spec // Java Specification @see "The Java Programming Language" // "Java Programming Language" @since Since-Text The content specified by Since-Text gives it to generate Documents add "Since" title. This text does not have a special internal structure. This tag indicates that the change or functionality is exist after the software version specified by Since-Text. For example: @since jdk1.1@serial field-description is used in document comments for default sequential domain. Optional Field-Description enhances the description capability of document comments on the domain. This combined description must explain the meaning of the domain and list acceptable values. This description can be multi-line as needed. An @since tag should be added to each sequential domain added after the initial version of the Serializable class. To obtain a private class, you can use the -Private option. Thus, to generate all public class and private class sequence form, you can run Javadoc with the -private option. For information on how to use these tags, as well as the corresponding example, see Sequential domain and data of the sequential domain and data of the Java object serialization specification. @ SerialField Field-Name Field-Type Field-Description Established a Serializable class serialPersistentFields ObjectStreamField document assembly members. ObjectStreamField should be used for each of a @serialField marker. @ serialData data-description data-description data to establish (and especially the optional data written Externalizable.writeExternal methods writeObject method writes all Data) Sequence and type documentation,. @ SerialData tag can be used in document comments for WriteObject, ReadObject, WriteExternal, and Readexternal methods. @ THROWS CLASS-NAME DESCRIPTION @Throws and @Exception tag synonym.

Add a "thrown" subtitle to the generated document with Class-Name and Description text. Where Class-Name is an exception name that the method can be thrown. If the class is not fully qualified, Javadoc uses the search order to find the class. @Version Version-Text When using the -Version option, use the content specified by Version-Text to generate a "version" subtitle. This text does not have a special internal structure. Document comments can only contain one @version tag. The version is usually referring to a software (such as a JDK) version containing this class or member. The marks can be used in this place where the markers can be used. Note that these four tags can be used in all document comments: @ see, @ link, @ snince, @ deprecated. Overview Document Tag Overview Tags You can appear in a document comment on an overview page (this document is usually located in the source file called OverView.html). As in any other document comment, these tags must be behind the description. Note - {@link} Tagged in an overview document in JDK 1.2 has a bug - document correctly, but no link. Overview Tag @see {@LINK} @since @SINCE package document tag packet tag can appear in a document comment on a package (this document is located in the source file called package.html). Package Tag @see {@LINK} @since @depRecated class and interface document tags The following is a tag that can appear in a document comment in a class or interface. Class / Interface Tag @see {@Link} @Since @DepRecated @Author @version class annotation example: / ** * Represents the class on the screen. * For example: *

 * window win = new window (parent); * win.show (); *  * * @Author sami shaio * @version 1.6, 06/25/99 * @see java. AWT.BASEWINDOW * @see java.awt.button * / class window extends basewindow {...} Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain Domain. Domain tag @see {@Link} @Since @Serialfield @serial @serialfield domain annotation example: / ** * The X coordinate of the component. * @See #getlocation () * / int x = 1263732; Constructor and Method Documentation The following is a tag in the document comment that can appear in the constructor or method. Method / Construction Function Tag @see {@Link} @Since @DepRecated @Param @Return @Throws (@Exception) @serialData Method Document Note Example: / ** * Returns the character of the specified index. Index * ranges to  0  to  length () - 1 . * * @Param INDEX's index of the character you want. * @Return you want.

* @Exception StringIndexOutofrangeException * If the index is not in the range  0  * to  length () - 1 . * @See java.lang.Character # charvalue () * / public char charat (int index) {...} Command line parameter file To reduce or simplify the javadoc command, you can specify one or more of which contain one source file. Name or package name file. In the command line, use the '@' character plus the file name to specify it as a list of files. When javadoc encounters parameters starting with character '@', it will operate the name in the file, as if these names are on the command line. For example, all package names can be listed in a file called Packages. This file may be shaped like: com.mypackage1, then run Javadoc: C: C: c: c:> javadoc -d apidocs @packages option Javadoc tool to determine its output using DOCLETS. Javadoc uses the default standard doclet unless you specify a custom doclet using the -Doclet option. Javadoc provides a set of command line options that can be used for any doclet - these options will be described in the subtitle javadoc option below. Standard DOCLET provides an additional command line option that will be introduced in the options provided by the subtitle standard doclets provided below. All option names are not case sensitive, but their parameters may be case sensitive. Options include: -1.1-author-bootclasspath-bottom-classpath-d-docencoding-doclet-docletpath-doctitle-encoding-extdirs-footer-group -header-help-helpfile-J-link-linkoffline-locale-nodeprecated-nodeprecatedlist- nohelp-noindex -nonavbar-notree -overview -package-private-protected-public-sourcepath-splitindex-stylesheetfile-title-use-verbose-version-windowtitle javadoc option -overview i> path / filename should be specified from javadoc path / filename as Overview documentation is obtained in the specified "source" file and put it in an overview page (overview-summary.html). Where Path / FileName is a relative path name relative to-SourcePath. Although any name can be used for FileName and place it anywhere in Path, it typically commands it to overview.html and put it in the source directory tree containing the top package directory. At this location, it is not necessary to PATH when establishing a package document, because -SourcePath will point to the file. For example, if the source of the java.lang package is / src / classes / java / lang /, you can make an overview file to /src/classes/overview.html. See the actual example. For information about the PATH / FileName specified file, see Overview Note File. In a certain case, an overview page will not be generated.

See the HTML framework for more information. -public only shows public classes and members. -Protected only shows protected and public classes and members. This is the default. -package only shows package, protected and public classes and members. -priVate displays all classes and members. -Help Shows Online Help, which will list these Javadoc and Doclet command line options. -Doclet class Specifies the class file that starts to generate a DocuT of the document. This doclet defines the contents and formats of the output. If the -Doclet option is not used, Javadoc generates the default HTML format using the standard DOCLET. This class must contain a start (root) method. The path to the startup class is defined by the -Docletpath option. -DocletPath ClassPathList Specifies the path to the Doclet class file, which is specified by the -Doclet option. If the Doclet is already in the search path, it is not necessary to use this option. -1.1 Generates documents with the appearance and function of documents generated by Javadoc 1.1. That is, the background of the page is gray, use the image to do header, using the Bullet list instead of the table, with a single-stage destination directory structure, does not include the inherited API, does not use the HTML framework, and does not support the internal class. This option also divides the index into one file per letter. If you want this look, this option is more advantageous than JavaDoc 1.1 is amended. Not all options can be used for -1.1 options. To see which options are available, executable: C:> javadoc -1.1 -help The -footer option displayed in this list is functionally identical to the -BOTTOM option described elsewhere in this page. The -title option is functionally with -DOCTITLE. -SourcePath SourcePathList When the package name is passed to the javadoc command, the search path of the search source file (.java) is specified. Note that only the SourcePath option can be used when specifying the package name with the javadoc command - it will not be positioned to the javadoc command. If-SourcePath is omitted, Javadoc uses the class path to find the source file (see -classpath). Set the SourcePathList to the root directory of the source tree that is generating the package of its document. For example, suppose to create a document for a package called com.mypackage, its source file is in: c: / user / src / com / mypackage / *. Java will specify SourcePath as C: / User / src, this directory contains COM / MyPackage, then providing the package name com.mypackage: javadoc -sourcePath C: / user / src com.mypackage This is quite easy to remember, pay attention to link the source path and the package name And change the point number to slash "/", will finally get the full path of the package: c: / user / src / com / mypackage. -Classpath classpathlist Specifies the path of Javadoc to find the reference class - reference class It is a class with a document plus any class they reference. Javadoc will search all the subdirectory of the specified path. ClassPathList can contain multiple paths that are separated by a semicolon. For how to specify ClassPathList, follow the instructions in the classpath document. If-SourcePath is omitted, Javadoc uses -classpath to find source files and class files (for backward compatibility).
Thus, if you want to search for source files and class files in different paths, you should use-SourcePath and -ClassPath options. For example, if you want to create a document of com.mypackage, its class is in directory C: / user / src / com / mypackage, and the package depends on the library in C: / user / lib, will be specified: C: > Javadoc -classpath / user / lib - SourcePath / user / src com.mypackage is the same as other tools, if -classpath is not specified, Javadoc will use the classPath environment variable (if it has been set). If both are not set, Javadoc searches from the current directory. See how to find classes for how Javadoc uses -ClassPath to find user classes and related expansion classes and self-entertainment. -BootClassPath ClassPathList Specifies the path where you have a class. They are named Java platform classes. This bootclasspath is part of Javadoc to find the search path of the source file and class file. See How to find classes for more information. Separate the directory with a semicolon (;) in ClassPathList. -extdirs dirlist Specifies the directory where the extension class is located. They are any classes that use the Java extension mechanism. This EXTDIRS is part of Javadoc to find some source files and some search paths in the file. For more information, see the -classpath above. Separate the directory with a semicolon (;) in Dirlist. -verbose provides more detailed information at Javadoc runtime. When using the Verbose option, the load source file is displayed, generates a document (one information of each source file) and sorting. The Verbose option causes additional information to specify the number of milliseconds that parse each Java source file. -locale language_country_variant Specifies the environment that Javadoc uses when generating documents. This parameter is an environment name, such as the java.util.locale document, such as en_us (English, US) or En_us_win (Windows Variable). The specified environment will cause javadoc to be a variety of information (the title of strings, list, and tables in the navigation bar, the annotation of the content, Stylesheet.css, etc.) Select the resource file using the environment. It also specifies the sort order of the alphabetical order, and the statement separator for determining the end of the first sentence. It does not determine the environment of the document that is specified in the documentation in the document class. -Encoding Name Specifies the source file encoding name, such as Eucjis / SJIS. If this option is not specified, the platform default converter is used. -Jflag passes Flag directly to running Javadoc runtime system Java. Note that there is no space between J and FLAG. For example, if you need to ensure that the system assignment 32 megauses is used to handle the generation document, you should use this flag as follows:? C:> Javadoc -j-xmx32m -j-xms32m com.mypackage Standard Database-DIRECTORY TRAY JAVADOC Save the destination directory of the generated HTML file. ("D" means "destination.") omission that this option will result in saving files into the current directory. The Directory can be an absolute path or relative path relative to the current working directory.
For example, the following code will generate a COM.MYPACKAGE package document and save the results in a C: / user / doc / directory: c:> javadoc -d / user / doc com.mypackage-use with document class and package Includes a "usage page. This page describes any API packages, classes, methods, constructor, and domains using any APIs for a given class or package. For a given class C, anything using class C will include a subclass of C, a domain that is declared as C, a method of returning C, and a method and constructor having a C-type parameter. For example, let's take a look at the contents of the "Usage" page that appears in String. GetName () method in the java.awt.font class returns the type String. Thus, GetName () uses String to find this method on the String's Usage page. Note that it generates documents that use the API without including implementation. If the method uses String in its implementation but does not return a string without receiving a string parameter, it will not be considered using String. You can go to the class or package first, then click the "Usage" link on the navigation bar to access the generated Usage page. -Version includes @version text in the generated document. This text will be omitted by default. -author includes @Author text in the generated document. -splitIndex divides the index file to multiple files, one file per letter, plus a file containing all index items starting with non-alphabatic characters. -windowTitle Title specifies the title in the HTML