Controls the general handling of Javadoc comments.

Figure 2.71. Javadoc settings page

Please refer to the section called “Templates” for information about how to define templates that are used for Javadoc comment generation.

Generate Javadoc comments

Enables or disables the comment auto-generation as a whole.

Since 1.2.1

Include inner classes

Enables comment auto-generation for inner classes, too. Auto-generation does not apply to anonymous inner classes.

Include Getter/Setter

Controls whether the auto-generation should be enabled for methods that follow the JavaBeans naming convention (Getter/Setter). Please note that you can control what methods should be recognized as Boolean Getters via a regular expression. Refer to “Boolean Getter Regex” for more information.

Since 1.3

Exclude Overridden/Implemented

Controls whether Javadoc comments should be generated for methods that are implementing/overriding others.

public interface Foo {
    /**
     * Does foo.
     */
    public void doFoo();
}

public abstract class BaseFoo implements Foo {
    public void doFoo() {
        /* ... */
    }
}

public abstract class FooImpl extends BaseFoo {
    @Override public void doFoo() {
        /* ... */
    }
}

With this option enabled, Jalopy would not generate Javadoc for doFoo() in BaseFoo or FooImpl, because they implement or override another method.

Since 1.8

Generate @see tags

Controls whether Javadoc generation for methods that are implementing or overriding others, creates @see tags to point to the referenced method. When disabled, Javadoc generation uses the descriptions given in the different templates.

package com.foo;


public interface Foo {
    /**
     * Does foo.
     */
    public void doFoo();
}

public abstract class BaseFoo implements Foo {
    
    /**
     * DOCME!
     */
    public void doFoo() {
        ...
    }

    /**
     * DOCME!
     */
    public void doBar() {
        ...
    }
}

public abstract class FooImpl extends BaseFoo {

    /**
     * DOCME!
     */
    @Override public void doFoo() {
        ...
    }
}

But when this option has been enabled, Jalopy automatically creates @see tags that references the overridden or implemented method in order to point to the documentation available there.

package com.foo;


public interface Foo {
    /**
     * Does foo.
     */
    public void doFoo();
}

public abstract class BaseFoo implements Foo {
    
    /**
     * @see com.foo.Foo#doFoo()
     */
    public void doFoo() {
        ...
    }

    /**
     * DOCME!
     */
    public void doBar() {
        ...
    }
}

public abstract class FooImpl extends BaseFoo {

    /**
     * @see com.foo.Foo$doFoo()
     */
    @Override public void doFoo() {
        ...
    }
}

Since 1.8

Reuse existing comments

When enabled, the textual contents of all existing comments that appear before a certain node are used as the description section (instead of the one defined in the template). Otherwise the generated Javadoc comment is simply inserted below any already existing comments.

Since 1.5

/*
 * HTML is the top level element
 */
public static Node parseDocument(Lexer lexer) {}

When the option is left disabled, the above example would become

/*
 * HTML is the top level element
 */
/**
 * DOCME!
 *
 * @param   lexer  DOCME!
 *
 * @return  DOCME!
 */
public static Node parseDocument(Lexer lexer) {}

But when the option is enabled, the result would be

/**
 * HTML is the top level element
 *
 * @param   lexer  DOCME!
 *
 * @return  DOCME!
 */
public static Node parseDocument(Lexer lexer) {}

Format bean property

Lets you control whether the value of the "property.name" local environment variable should be split into several chunks or just have its prefix stripped upon interpolation.

When enabled, the property name is determined from the method name by stripping the bean prefix and taking any upper case letter followed by a lower case letter and put a space in front of it. E.g. “getImportanceValue” would result in "Importance Value", “getABSValue” in "ABS Value" and “isValid” in “Valid”. The case of all chunks is adjusted according to the rules as sketched below.

When disabled, just the bean prefix is stripped and the case of the first letter adjusted according to the rules laid out in the JavaBean spec.

Since 1.3

/**
 * Sets the value of the $property.name$ property.
 *
 * @param name $property.name$ property value.
 */
public void setImportanceValue(String value) {
    ...
}

/**
 * Sets the value of the Importance Value property.
 *
 * @param  name  importance value property value.
 */
public void setImportanceValue(String value) {
    ...
}

/**
 * Sets the value of the ImportanceValue property.
 *
 * @param  name  importanceValue property value.
 */
public void setImportanceValue(String value) {
    ...
}

Enable for

The table component lets you selectively enable the auto-generation of missing Javadoc comments for specific code elements and access levels. Please note that you can selectively disable Javadoc generation in source code files by using a special pragma comment. Refer to the Pragma comments section for more information.

Disable for

Lets you disable Javadoc generation within classes that extend a certain class or implement a certain interface. This option is useful if you generally want to document inner classes, but obmit documentation for certain inner classes like e.g. Swing listeners. Use the Add... button to define the type names of extends or implements clauses that should disable Javadoc generation when found.

Please note that Javadoc generation will only be disabled for the methods, fields etc. defined within a class - the class declaration itself is not affected. Please note further that comparison is done using exact string matching: you need to specify the type name exactly as it appears in the source file. ActionListener and java.awt.event.ActionListener are treated as two different type names. If you mix qualified and simple type names in your source, you need to define both type names here.

Since 1.6

/**
 * A sample class.
 */
public class Foo {

    class MyAction implements ActionListener {

        public void actionPerformed(ActionEvent ev) {
            ...
        }
    }
}

Javadoc generation without exclusions could look like:

/**
 * A sample class.
 */
public class Foo {

    /**
     * DOCME!
     *
     * @author   Joe Tiger
     * @version  $version$
     */
    class MyAction implements ActionListener {

        /**
         * DOCME!
         *
         * @param  ev  DOCME!
         */
        public void actionPerformed(ActionEvent ev) {
            ...
        }
    }
}

But with Javadoc generation disabled for ActionListener, the result could look like:

/**
 * A sample class.
 */
public class Foo {

    /**
     * DOCME!
     *
     * @author   Joe Tiger
     * @version  $version$
     */
    class MyAction implements ActionListener {

        public void actionPerformed(ActionEvent ev) {
            ...
        }
    }
}

Please note how Javadoc is added for the inner class declaration but omitted for the contained method!