IllegalType

Since Checkstyle 3.2

Description

Checks that particular classes or interfaces are never used.

Rationale: Helps reduce coupling on concrete classes.

For additional restriction of type usage see also: IllegalInstantiation, IllegalImport

Properties

name description type default value since
ignoredMethodNames Specify methods that should not be checked. String[] getEnvironment, getInitialContext 3.2
illegalAbstractClassNameFormat Specify RegExp for illegal abstract class names. Pattern "^(.*[.])?Abstract.*$" 3.2
illegalClassNames Specify classes that should not be used as types in variable declarations, return values or parameters. String[] HashMap, HashSet, LinkedHashMap, LinkedHashSet, TreeMap, TreeSet, java.util.HashMap, java.util.HashSet, java.util.LinkedHashMap, java.util.LinkedHashSet, java.util.TreeMap, java.util.TreeSet 3.2
legalAbstractClassNames Define abstract classes that may be used as types. String[] {} 4.2
memberModifiers Control whether to check only methods and fields with any of the specified modifiers. This property does not affect method calls nor method references nor record components. subset of tokens TokenTypes {} 6.3
validateAbstractClassNames Control whether to validate abstract class names. boolean false 6.10
tokens tokens to check subset of tokens ANNOTATION_FIELD_DEF , CLASS_DEF , INTERFACE_DEF , METHOD_CALL , METHOD_DEF , METHOD_REF , PARAMETER_DEF , VARIABLE_DEF , PATTERN_VARIABLE_DEF , RECORD_DEF , RECORD_COMPONENT_DEF . ANNOTATION_FIELD_DEF , CLASS_DEF , INTERFACE_DEF , METHOD_CALL , METHOD_DEF , METHOD_REF , PARAMETER_DEF , VARIABLE_DEF , PATTERN_VARIABLE_DEF , RECORD_DEF , RECORD_COMPONENT_DEF . 3.2

Notes

It is possible to set illegal class names via short or canonical name. Specifying illegal type invokes analyzing imports and Check puts violations at corresponding declarations (of variables, methods or parameters). This helps to avoid ambiguous cases, e.g.: java.awt.List was set as illegal class name, then, code like: 

import java.util.List;
...
List list; //No violation here

will be ok.

In most cases it's justified to put following classes to illegalClassNames:

  • GregorianCalendar
  • Hashtable
  • ArrayList
  • LinkedList
  • Vector

as methods that are differ from interface methods are rarely used, so in most cases user will benefit from checking for them.

Examples

To configure the default check: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType"/>
  </module>
</module>

Example:

public class Test extends TreeSet { // violation
  public <T extends java.util.HashSet> void method() { // violation

    LinkedHashMap<Integer, String> lhmap =
        new LinkedHashMap<Integer, String>(); // violation
    TreeMap<Integer, String> treemap = new TreeMap<Integer, String>(); // violation
    Test t; // OK
    HashMap<String, String> hmap; // violation
    Queue<Integer> intqueue; // OK

    java.lang.IllegalArgumentException illegalex; // OK
    java.util.TreeSet treeset; // violation
  }

}

To configure the Check so that particular tokens are checked: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType">
      <property name="tokens" value="METHOD_DEF"/>
    </module>
  </module>
</module>

Example:

public class Test extends TreeSet { // OK
  public <T extends java.util.HashSet> void method() { // violation

    LinkedHashMap<Integer, String> lhmap = new LinkedHashMap<Integer, String>(); // OK

    java.lang.IllegalArgumentException illegalex; // OK
    java.util.TreeSet treeset; // Ok
  }

  public <T extends java.util.HashSet> void typeParam(T t) {} // violation

  public void fullName(TreeSet a) {} // OK

}

To configure the Check so that it ignores function() methods: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType">
      <property name="ignoredMethodNames" value="function"/>
    </module>
  </module>
</module>

Example:

public class Test {
  public HashMap<String, String> function() { // OK
    // code
  }

  public HashMap<String, String> function1() { // violation
    // code
  }
}

To configure the Check so that it validates abstract class names: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType">
      <property name="validateAbstractClassNames" value="true"/>
      <property name="illegalAbstractClassNameFormat" value="Gitt"/>
    </module>
  </module>
</module>

Example:

class Test extends Gitter { // violation
}

class Test1 extends Github { // OK
}

To configure the Check so that it verifies only public, protected or static methods and fields: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType">
      <property name="memberModifiers" value="LITERAL_PUBLIC,
        LITERAL_PROTECTED, LITERAL_STATIC"/>
    </module>
  </module>
</module>

Example:

public class Test {
  public HashMap<String, String> function1() { // violation
    // code
  }

  private HashMap<String, String> function2() { // OK
    // code
  }

  protected HashMap<Integer, String> function3() { // violation
    // code
  }

  public static TreeMap<Integer, String> function4() { // violation
    // code
  }

}

To configure the check so that it verifies usage of types Boolean and Foo: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType">
      <property name="illegalClassNames" value="Boolean, Foo"/>
    </module>
  </module>
</module>

Example:

public class Test {

  public Set<Boolean> set; // violation
  public java.util.List<Map<Boolean, Foo>> list; // violation

  private void method(List<Foo> list, Boolean value) { // violation
    SomeType.<Boolean>foo(); // violation
    final Consumer<Foo> consumer = Foo<Boolean>::foo; // violation
  }

  public <T extends Boolean, U extends Serializable> void typeParam(T a) {} // violation

  public void fullName(java.util.ArrayList<? super Boolean> a) {} // violation

  public abstract Set<Boolean> shortName(Set<? super Boolean> a); // violation

  public Set<? extends Foo> typeArgument() { // violation
    return new TreeSet<Foo<Boolean>>();
  }

}

To configure the check to target fields types only: 

<module name="Checker">
  <module name="TreeWalker">
    <module name="IllegalType">
      <property name="illegalClassNames" value="java.util.Optional"/>
      <property name="tokens" value="VARIABLE_DEF"/>
      <property name="id" value="IllegalTypeOptionalAsField"/>
    </module>
    <module name="SuppressionXpathSingleFilter">
      <property name="query" value="//METHOD_DEF//*"/>
      <property name="id" value="IllegalTypeOptionalAsField"/>
    </module>
  </module>
</module>

Example:

import java.util.Optional;

public class Main {

  static int field1 = 4; // OK
  public Optional<String> field2; // violation, usage of type 'Optional' is not allowed
  protected String field3; // OK
  Optional<String> field4; // violation, usage of type 'Optional' is not allowed
  private Optional<String> field5; // violation, usage of type 'Optional' is not allowed

  void foo() {
    Optional<String> i; // OK
  }
  public <T extends java.util.Optional> void method(T t) { // OK
    Optional<T> i; // OK
  }
}

Example of Usage

Violation Messages

All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.

Package

com.puppycrawl.tools.checkstyle.checks.coding

Parent Module

TreeWalker