请求详解PMD规则AccessorMethodGeneration：含内外类字段与方法示例

Hey there! Let's dive into PMD's AccessorMethodGeneration rule (priority 3) — this one is all about steering clear of those hidden, auto-generated accessor methods that compilers sneak in when inner/outer classes access each other's private fields or methods. Here's a breakdown of what it is, why it matters, and concrete examples to fix it.

What this rule enforces #

This rule flags code where the Java compiler has to generate synthetic accessor methods (think names like $access$000 or $get$outerPrivateField) to let an inner class access an outer class's private members, or vice versa. These methods aren't written by you — they're compiler-generated hacks that bypass normal encapsulation.

Why you should care #

Avoiding these synthetic methods has three key benefits:

• Performance: Each synthetic method adds an extra method call overhead. It's tiny per call, but adds up in high-frequency code paths.
• Code transparency: These methods don't appear in your source code, so debugging or profiling can get confusing when you see them in stack traces.
• Encapsulation respect: Private members are meant to be hidden. Synthetic methods create an unintended backdoor, breaking the encapsulation you intended.

Field Access Examples #

Bad Code (Triggers the Rule) #

Here's a classic case where an inner class directly accesses an outer class's private field — the compiler will generate a synthetic accessor here:

public class OuterClass {
    private String outerPrivateField = "My secret value";

    public class InnerClass {
        public void printOuterField() {
            // Compiler generates a synthetic method to fetch outerPrivateField
            System.out.println(outerPrivateField);
        }
    }
}

When you compile this, the compiler adds a hidden method like String OuterClass.$access$000(OuterClass) to let InnerClass get the private field. PMD flags this as a violation.

Good Code (Avoids the Rule) #

Fix this by either adding an explicit public accessor method, or moving the logic that uses the field into the outer class:

Option 1: Explicit accessor method

public class OuterClass {
    private String outerPrivateField = "My secret value";

    // Explicit public accessor (you control this)
    public String getOuterPrivateField() {
        return outerPrivateField;
    }

    public class InnerClass {
        public void printOuterField() {
            // Use the explicit accessor instead of direct private access
            System.out.println(getOuterPrivateField());
        }
    }
}

Option 2: Move logic to the outer class (better if inner class only needs to trigger an action)

public class OuterClass {
    private String outerPrivateField = "My secret value";

    public void printOuterField() {
        System.out.println(outerPrivateField);
    }

    public class InnerClass {
        public void triggerPrint() {
            // Call a business method on the outer class instead of accessing the field
            printOuterField();
        }
    }
}

Method Access Examples #

Bad Code (Triggers the Rule) #

This happens when an inner class calls an outer class's private method — again, the compiler generates a synthetic accessor:

public class OuterClass {
    private void outerPrivateMethod() {
        System.out.println("Executing outer private logic");
    }

    public class InnerClass {
        public void callOuterMethod() {
            // Compiler generates a synthetic method to invoke outerPrivateMethod
            outerPrivateMethod();
        }
    }
}

Good Code (Avoids the Rule) #

You have two solid fixes here:

1. Make the method package-private: If the inner class is in the same package (which it is, since it's a nested class), changing the private method to package-private (no access modifier) lets the inner class access it directly without synthetic methods.

public class OuterClass {
    // Package-private access: inner class can call this directly
    void outerPackagePrivateMethod() {
        System.out.println("Executing outer package-private logic");
    }

    public class InnerClass {
        public void callOuterMethod() {
            outerPackagePrivateMethod();
        }
    }
}

2. Add a public wrapper method: If you want to keep the original method private, wrap it in a public method that the inner class can call:

public class OuterClass {
    private void outerPrivateMethod() {
        System.out.println("Executing outer private logic");
    }

    public void runOuterPrivateLogic() {
        outerPrivateMethod();
    }

    public class InnerClass {
        public void callOuterMethod() {
            runOuterPrivateLogic();
        }
    }
}

内容的提问来源于stack exchange，提问作者user3382677