How to reference a method in javadoc?

Enticing method referencing

By correctly using {@link}, you place highlight on the critical features of your methods that provide users with quick access and understanding, thereby enriching the value of your Javadoc content. Here's an example:

/**
 * Uses the mystical power of {@link Math#pow(double, double)} 
 * to calculate the power. Brace yourselves!
 */
public double calculatePower(double base, int exponent) {
    return Math.pow(base, exponent); // Power to the developers!
}


Generating succinct and meaningful links not only elevates the readability of your documentation but also its functionality. The {@linkplain} tag allows for alternative display text, providing even more context where required:

/**
 * Initial setup that must be invoked before {@linkplain #start() starting}.
 * (Don't skip leg day!)
 */
public void init() {
    // Initialization code goes here.
}


Crafting potent connections

When referring to methods in different packages, full qualification via {@link package.ClassName#methodName()} improves navigation and understanding:

/**
 * Follows the singleton pattern inspired by {@link java.lang.Runtime#getRuntime()}.
 * (There can be only one!)
 */
public enum Singleton {
    INSTANCE;
}


Moreover, don't forget to employ @see for chaining method references:

/**
 * Discovers services. Now, isn't that exciting?
 *
 * @see #find(String) Seek and you shall find.
 * @see #findFiltered(String, java.util.function.Predicate) 
 * For the picky ones.
 */
public void discover() {
    // Let the discovery commence!
}


Remember to manually update your custom labels, as the process of refactoring methods doesn't automatically usher in the name changes.

Handling overloaded and generic methods

Linking to overloaded methods requires a type-disambiguation approach:

/**
 * Parses the input. Brace for an adventure!
 *
 * @see #parse(String) For word lovers.
 * @see #parse(File) For file hoarders.
 */
public void parse(Input input) {
    // parsing magic
}


When dealing with generics, aim to be precise while avoiding unnecessary clutter:

/**
 * Processes fancy data elements, like cooking without a recipe!
 *
 * @param <T> the type of elements
 * @see #process(Object) for processing individual items.
 * @see #processAll(Collection) for the hearty meals.
 */
public <T> void process(T data) {
    // process the data element
}


Closing with a bang!

Linking methods illuminates the architectural patterns and design embedded in your code, tripling the value of your symbols by being informative, connected, and concise.

In conclusion, make method references the portal to better understanding. This will not only enhance navigability but foster familiarity with the codebase, proving incredibly beneficial for maintainers and newbie developers.