Java父类方法参数优化与SonarQube警告处理：模板方法模式实践

abstract class Parent {
    protected void doSomething(Object firstParameter, Object secondParameter) {
        // do something with firstParameter
        System.out.println("Parent processing firstParameter: " + firstParameter);
        // secondParameter is not used here
    }
}

class ChildThatUsesSecondParameter extends Parent {
    @Override
    protected void doSomething(Object firstParameter, Object secondParameter) {
        super.doSomething(firstParameter, secondParameter);
        // Child class uses secondParameter for additional logic
        System.out.println("Child processing secondParameter: " + secondParameter);
    }
}

class ChildThatDoesNotUseSecondParameter extends Parent {
    @Override
    protected void doSomething(Object firstParameter, Object secondParameter) {
        super.doSomething(firstParameter, secondParameter);
        // This child only relies on parent's logic, secondParameter is still unused by its specific override
    }
}

class MyParameters {
    private Object firstParameter;
    private Object secondParameter;

    public MyParameters(Object firstParameter, Object secondParameter) {
        this.firstParameter = firstParameter;
        this.secondParameter = secondParameter;
    }

    public Object getFirstParameter() {
        return firstParameter;
    }

    public Object getSecondParameter() {
        return secondParameter;
    }
}

abstract class ParentWithParamObject {
    protected void doSomething(MyParameters params) {
        System.out.println("Parent processing firstParameter: " + params.getFirstParameter());
        // Parent still doesn't use params.getSecondParameter() directly
    }
}

class ChildWithParamObject extends ParentWithParamObject {
    @Override
    protected void doSomething(MyParameters params) {
        super.doSomething(params);
        System.out.println("Child processing secondParameter: " + params.getSecondParameter());
    }
}

/**
 * 抽象父类：定义算法骨架
 */
abstract class ParentTemplate {
    /**
     * 模板方法：定义了操作的整体流程
     * firstParameter 是所有子类都需要处理的通用参数
     * secondParameter 是用于特定扩展行为的参数
     */
    protected void doSomething(Object firstParameter, Object secondParameter) {
        // 步骤1：所有子类共享的通用逻辑，使用 firstParameter
        System.out.println("Parent: Processing common logic with firstParameter: " + firstParameter);

        // 步骤2：将特定行为委托给抽象方法，由子类实现
        // 只有需要 secondParameter 的子类才会真正使用它
        doSomethingElse(secondParameter);
    }

    /**
     * 抽象方法：定义了需要子类实现的可变步骤
     * 传入 secondParameter，由子类决定是否使用
     */
    protected abstract void doSomethingElse(Object secondParameter);
}

/**
 * 抽象中间类：为不需要额外行为的子类提供默认的空实现
 * 避免每个“不额外处理”的子类都去重写一个空方法
 */
abstract class DoNothingElse extends ParentTemplate {
    @Override
    protected void doSomethingElse(Object secondParameter) {
        // 默认不执行任何操作
        System.out.println("DoNothingElse: No specific additional processing.");
    }
}

/**
 * 具体子类A：需要使用 secondParameter 进行额外处理
 */
class ChildThatDoesSomethingElse extends ParentTemplate {
    @Override
    protected void doSomethingElse(Object secondParameter) {
        // 子类实现了特定逻辑，使用了 secondParameter
        System.out.println("ChildThatDoesSomethingElse: Performing extra steps with secondParameter: " + secondParameter);
    }
}

/**
 * 具体子类B：不需要使用 secondParameter 进行额外处理
 * 直接继承 DoNothingElse 即可，无需重写 doSomethingElse
 */
class ChildThatDoesNothingElse extends DoNothingElse {
    // 无需重写 doSomethingElse，继承了 DoNothingElse 的空实现
}

public class TemplateMethodDemo {
    public static void main(String[] args) {
        System.out.println("--- ChildThatDoesSomethingElse ---");
        ChildThatDoesSomethingElse childA = new ChildThatDoesSomethingElse();
        childA.doSomething("CommonDataA", "SpecificDataA");

        System.out.println("\n--- ChildThatDoesNothingElse ---");
        ChildThatDoesNothingElse childB = new ChildThatDoesNothingElse();
        childB.doSomething("CommonDataB", "SpecificDataB");
    }
}

--- ChildThatDoesSomethingElse ---
Parent: Processing common logic with firstParameter: CommonDataA
ChildThatDoesSomethingElse: Performing extra steps with secondParameter: SpecificDataA

--- ChildThatDoesNothingElse ---
Parent: Processing common logic with firstParameter: CommonDataB
DoNothingElse: No specific additional processing.