## Why is this an issue?

A typical code smell known as unused function parameters refers to parameters declared in a function but not used anywhere within the function’s body. While this might seem harmless at first glance, it can lead to confusion and potential errors in your code. Disregarding the values passed to such parameters, the function’s behavior will be the same, but the programmer’s intention won’t be clearly expressed anymore. Therefore, removing function parameters that are not being utilized is considered best practice.

### Exceptions

The rule will not raise issues for unused parameters:

- that are annotated with `@javax.enterprise.event.Observes`
- in overrides and implementation methods
- in interface `default` methods
- in non-private methods that only `throw` or that have empty bodies
- in annotated methods, unless the annotation is `@SuppressWarning("unchecked")` or `@SuppressWarning("rawtypes")`, in which case the annotation will be ignored
- in overridable methods (non-final, or not member of a final class, non-static, non-private), if the parameter is documented with a proper javadoc.

## How to fix it

Having unused function parameters in your code can lead to confusion and misunderstanding of a developer’s intention. They reduce code readability and introduce the potential for errors. To avoid these problems, developers should remove unused parameters from function declarations.

### Code examples

#### Noncompliant code example

    void doSomething(int a, int b) { // Noncompliant, "b" is unused
      compute(a);
    }

#### Compliant solution

    void doSomething(int a) {
      compute(a);
    }

Examples of exceptions:

    @Override
    void doSomething(int a, int b) {     // no issue reported on b
      compute(a);
    }

    public void foo(String s) {
      // designed to be extended but noop in standard case
    }

    protected void bar(String s) {
      //open-closed principle
    }

    public void qix(String s) {
      throw new UnsupportedOperationException("This method should be implemented in subclasses");
    }

    /**
     * @param s This string may be used for further computation in overriding classes
     */
    protected void foobar(int a, String s) { // no issue, method is overridable and unused parameter has proper javadoc
      compute(a);
    }

## Resources

- CERT, MSC12-C. - Detect and remove code that has no effect or is never executed