Checkstyleチェック項目：Coding
ver 10.3.1
ArrayTrailingComma
配列の初期化時に、末尾にコンマが含まれているかどうかをチェックする。
デフォルトでは、配列の最後の要素と同じ行に左中括弧も右中括弧もない場合、最後にコンマが必要となる。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| alwaysDemandTrailingComma | boolean | false | 常に末尾のコンマをチェックするかどうか |
チェック設定例
プロパティ設定なし
<module name="ArrayTrailingComma"/>
プロパティ設定あり
<module name="ArrayTrailingComma"> <property name="alwaysDemandTrailingComma" value="true"/> </module>
チェック実行例
プロパティ設定なし
// OK int[] numbers = { 1, 2, 3 }; // NG 末尾にコンマが必要 boolean[] bools = { true, true, false };
プロパティ設定あり
// NG 「alwaysDemandTrailingComma=true」なので末尾にコンマが必要 int[] numbers = { 1, 2, 3 }; // NG 末尾にコンマが必要 boolean[] bools = { true, true, false };
AvoidDoubleBraceInitialization
二重括弧初期化(DBI)を検出する。
DBI：最初の括弧で匿名クラスを生成し、次の括弧が初期化ブロックでオブジェクトを初期化する記述方法のこと。参考
プロパティ
なし
チェック設定例
<module name="AvoidDoubleBraceInitialization"/>
チェック実行例
class MyClass { // OK List<Integer> list1 = new ArrayList<>(); list1.add(1); // NG DBIは使用しない List<String> list2 = new ArrayList<>() { { add("aaa"); } }; }
AvoidInlineConditionals
インライン条件文を検出する。
〇 インライン条件文のサンプル
String a = getParameter("a");
String b = (a == null || a.length() < 1) ? null : a.substring(1);
プロパティ
なし
チェック設定例
<module name="AvoidInlineConditionals"/>
チェック実行例
// OK int x = 5; boolean foobar = (x == 5); // NG インライン条件文は使用しない String text; text = (text == null) ? "" : text;
AvoidNoArgumentSuperConstructorCall
引数なしのスーパークラスのコンストラクタ呼出しがあるかどうかをチェックする。
コンストラクタ本体は暗黙のうちにスーパークラスのコンストラクタを呼出しているため、 super() の明示的な呼出しは不要。
プロパティ
なし
チェック設定例
<module name="AvoidNoArgumentSuperConstructorCall"/>
チェック実行例
class MyClass extends ParentClass { // NG 明示的にsuper();を呼び出さない MyClass() { super(); } // OK MyClass(int arg) { super(arg); } // OK MyClass(long arg) { } }
CovariantEquals
共変なequals()メソッドを定義しているクラスやレコードが、equals(Object)メソッドもオーバーライドしているかどうかをチェックする。
共変なequals()メソッド：equals(Object) と同様のメソッドであるが、引数の型が共変（Objectの任意のサブクラス）なメソッドのこと。
プロパティ
なし
チェック設定例
<module name="CovariantEquals"/>
チェック実行例
// NG equals(Object)がオーバーライドされていない class MyClass { public boolean equals(Test i) { return false; } } // OK class MyClass { public boolean equals(Test i) { return false; } public boolean equals(Object i) { return false; } }
DeclarationOrder
クラス、レコード、インタフェース宣言の各部分が、Javaプログラミング言語のコード規約で推奨される順序で表示されているかどうかをチェックする。
Javaプログラミング言語のコード規約によると、クラスやインターフェースの宣言は、次のような順序で記述することになっている。
- クラス（static）変数
public, protected, パッケージプライベート, privateの順に記述 - インスタンス変数
public, protected, パッケージプライベート, privateの順に記述 - コンストラクタ
- メソッド
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| ignoreConstructors | boolean | false | コンストラクタを無視するかどうか |
| ignoreModifiers | boolean | false | 修飾子を無視するかどうか |
チェック設定例
プロパティ設定なし
<module name="ArrayTrailingComma"/>
プロパティ設定あり
<module name="DeclarationOrder"> <property name="ignoreConstructors" value="true"/> <property name="ignoreModifiers" value="true"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { public int a; protected int b; // NG protectedなメンバ変数より上に記述するべき public int c; MyClass() { this.a = 0; } public void foo() { } // NG メソッドより上に記述するべき MyClass(int a) { this.a = a; } // NG メンバ変数はメソッド・コンストラクタより上に記述するべき private String name; }
プロパティ設定あり
public class MyClass { public int a; protected int b; // OK 「ignoreModifiers=true」なので修飾子の順番はチェックされない public int c; MyClass() { this.a = 0; } public void foo() { } // OK 「ignoreConstructors=true」なのでコンストラクタはチェックされない MyClass(int a) { this.a = a; } // NG メンバ変数はメソッド・コンストラクタより上に記述するべき private String name; }
DefaultComesLast
switch文の中で default がすべてのcaseの後にあることをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| skipIfLastAndSharedWithCase | boolean | false | defaultが最後でない場合に、caseと一緒にいるdefaultを許可するかどうか |
チェック設定例
プロパティ設定なし
<module name="DefaultComesLast"/>
プロパティ設定あり
<module name="DefaultComesLast"> <property name="skipIfLastAndSharedWithCase" value="true"/> </module>
チェック実行例
プロパティ設定なし
// OK switch (i) { case 1: break; case 2: break; default: break; } // NG default の後ろにも case が存在している switch (i) { case 1: break; default: break; case 2: break; } // NG default の後ろにも case が存在している switch (i) { case 1: break; case 2: default: break; case 3: break; }
プロパティ設定あり
// OK switch (i) { case 1: break; case 2: break; default: break; } // NG default の後ろにも case が存在している switch (i) { case 1: break; default: break; case 2: break; } // OK 「skipIfLastAndSharedWithCase=true」のため、caseと一緒にいる場合はOK switch (i) { case 1: break; case 2: default: break; case 3: break; }
EmptyStatement
プロパティ
なし
チェック設定例
<module name="EmptyStatement"/>
チェック実行例
public void foo() { int i = 5; // NG (i > 3)の後ろのセミコロンは不要 if (i > 3); i++; // NG (i = 0; i < 5; i++)の後ろのセミコロンは不要 for (i = 0; i < 5; i++); i++; // OK while (i > 10) i++; }
EqualsAvoidNull
Stringのequals()メソッド呼び出し時にnullでない値が呼び元となっていることをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| ignoreEqualsIgnoreCase | boolean | false | String.equalsIgnoreCase(String)呼び出しの場合を無視するかどうか |
チェック設定例
プロパティ設定なし
<module name="EqualsAvoidNull"/>
プロパティ設定あり
<module name="EqualsAvoidNull"> <property name="ignoreEqualsIgnoreCase" value="true"/> </module>
チェック実行例
プロパティ設定なし
String nullString = null; // NG nullかもしれない値が呼び元になっている nullString.equals("String"); // OK "String".equals(nullString); // NG nullかもしれない値が呼び元になっている nullString.equalsIgnoreCase("String"); // OK "String".equalsIgnoreCase(nullString);
プロパティ設定あり
String nullString = null; // NG nullかもしれない値が呼び元になっている nullString.equals("String"); // OK "String".equals(nullString); // OK 「ignoreEqualsIgnoreCase=true」なのでequalsIgnoreCase(String)の呼び出しはチェックされない nullString.equalsIgnoreCase("String"); // OK "String".equalsIgnoreCase(nullString);
EqualsHashCode
equals() と hashCode() のどちらかをオーバーライドしているクラスが、もう一方もオーバーライドしているかどうかをチェックする。
プロパティ
なし
チェック設定例
<module name="EqualsHashCode"/>
チェック実行例
// NG equals(Object)のオーバーライドがない public static class Example1 { public int hashCode() { } public boolean equals(String o) { } } // NG hashCode()のオーバーライドがない public static class Example2 { public boolean equals(Object o) { } public boolean equals(String o) { } } // OK public static class Example3 { public int hashCode() { } public boolean equals(Object o) { } public boolean equals(String o) { } }
ExplicitInitialization
クラスまたはオブジェクトのメンバが明示的にその型のデフォルト値に初期化されているかどうかをチェックする。
オブジェクトの場合はnull、数値型およびcharの場合は0、booleanの場合はfalse。
各インスタンス変数は、同じ値で2回初期化されることになるので非効率。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| onlyObjectReferences | boolean | false | オブジェクトのNULLへの明示的な初期化のみをチェックするかどうか |
チェック設定例
プロパティ設定なし
<module name="ExplicitInitialization"/>
プロパティ設定あり
<module name="ExplicitInitialization"> <property name="onlyObjectReferences" value="true"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { // NG intのデフォルト値で明示的に初期化しない private int intField1 = 0; // OK private int intField2 = 1; // OK private int intField3; // NG objectのデフォルト値で明示的に初期化しない private Obj objField1 = null; // OK private Obj objField2 = new Obj(); // OK private Obj objField3; }
プロパティ設定あり
public class MyClass { // OK 「onlyObjectReferences=true」なのでチェックされない private int intField1 = 0; // OK private int intField2 = 1; // OK private int intField3; // NG objectのデフォルト値で明示的に初期化しない private Obj objField1 = null; // OK private Obj objField2 = new Obj(); // OK private Obj objField3; }
FallThrough
switch の case にコードが含まれているが、break、return、throw、continue文がない箇所がないかどうかをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| checkLastCaseGroup | boolean | false | 最後のcaseをチェックするかどうか |
| reliefPattern | Pattern | `"falls?[ -]?thr(u | ough)"`|警告を抑制するコメントの正規表現 |
チェック設定例
プロパティ設定なし
<module name="FallThrough"/>
プロパティ設定あり
<module name="FallThrough"> <property name="checkLastCaseGroup" value="true"/> <property name="reliefPattern" value="FALL?[ -]?THROUGH"/> </module>
チェック実行例
プロパティ設定なし
public void foo() throws Exception { int i = 0; while (i >= 0) { switch (i) { // NG caseにコードが含まれているのに // break, return, continueなどが記述されていない case 1: i++; case 2: i++; break; // チェック抑制のコメントがあるのでOK case 3: i++; // fall-through // 最後のケースはチェックされないためOK case 4: i++; } } }
プロパティ設定あり
public void foo() throws Exception { int i = 0; while (i >= 0) { switch (i) { // NG caseにコードが含まれているのに // break, return, continueなどが記述されていない case 1: i++; case 2: i++; break; // NG チェック抑制のコメントが「reliefPattern」に設定した正規表現にマッチしないのでチェックされる case 3: i++; // fall-through // NG 「checkLastCaseGroup=true」なので最後のケースもチェックされる case 4: i++; } } }
FinalLocalVariable
値が変更されることのないローカル変数が final で宣言されているかどうかをチェックする。
変更されないパラメータが final と宣言されているかどうかもチェックするように設定することができる。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| validateEnhancedForLoopVariable | boolean | false | 拡張for文の変数をチェックするかどうか |
| tokens | トークンのサブセット | VARIABLE_DEF | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| PARAMETER_DEF | パラメータ宣言 |
| VARIABLE_DEF | ローカル変数・フィールド宣言 |
チェック設定例
プロパティ設定なし
<module name="FinalLocalVariable"/>
プロパティ設定あり
<module name="FinalLocalVariable"> <property name="tokens" value="VARIABLE_DEF,PARAMETER_DEF"/> <property name="validateEnhancedForLoopVariable" value="true"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { // OK パラメータはチェック対象外 static int foo(int x, int y) { return x + y; } public static void main (String []args) { // OK 拡張for文の変数はチェック対象外 for (String i : args) { System.out.println(i); } // NG resultは値が変更されないのでfinalを付与する int result = foo(1, 2); } }
プロパティ設定あり
public class MyClass { // NG パラメータもチェック対象なので、変更されない場合はfinalを付与する static int foo(int x, int y) { return x + y; } public static void main (String []args) { // NG 「validateEnhancedForLoopVariable=true」なので // finalがないとチェックNG for (String i : args) { System.out.println(i); } // NG resultは値が変更されないのでfinalを付与する int result=foo(1,2); } }
HiddenField
ローカル変数やパラメータが同じクラスで定義されているフィールドを隠してしまっていないかをチェックする。
セッターを無視するようにチェックを設定することが出来る。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| ignoreFormat | Pattern | null | 無視する変数名やパラメータ名の正規表現 |
| ignoreConstructor Parameter | boolean | false | コンストラクタのパラメータを無視するかどうか |
| ignoreSetter | boolean | false | セッターのパラメータを無視するかどうか |
| setterCan ReturnItsClass | boolean | false | セッターの定義を拡張して、クラスのインスタンスを返すメソッドを含めることができるようにするかどうか |
| ignoreAbstract Methods | boolean | false | 抽象メソッドのパラメータを無視するかどうか |
| tokens | トークンのサブセット | VARIABLE_DEF, PARAMETER_DEF, PATTERN_VARIABLE_DEF, LAMBDA, RECORD_COMPONENT_DEF | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| LAMBDA | ラムダ式の-> |
| PARAMETER_DEF | パラメータ宣言 |
| PATTERN_VARIABLE_DEF | パターン変数宣言 |
| RECORD_COMPONENT_DEF | レコードコンポーネント宣言 |
| VARIABLE_DEF | 変数宣言 |
チェック設定例
プロパティ設定なし
<module name="HiddenField"/>
プロパティ設定あり
<module name="HiddenField"> <property name="ignoreFormat" value="^testField"/> <property name="ignoreConstructorParameter" value="true"/> <property name="ignoreSetter" value="true"/> <property name="setterCanReturnItsClass" value="true"/> <property name="ignoreAbstractMethods" value="true"/> </module>
チェック実行例
プロパティ設定なし
public abstract class SomeClass { private String field; private String testField; // NG フィールド名と同じパラメータ名 abstract void foo(String field); // NG フィールド名と同じパラメータ名 public SomeClass(String testField) { } // NG フィールド名と同じパラメータ名 public void method(String testField) { } // OK public void method(String param) { String field = param; } // NG フィールド名と同じパラメータ名 public void setField(String field) { this.field = field; } // NG フィールド名と同じパラメータ名 public SomeClass setField(String testField) { this.field = field; } }
プロパティ設定あり
public abstract class SomeClass { private String field; private String testField; // OK 「ignoreAbstractMethods=true」なのでチェックされない abstract void foo(String field); // OK 「ignoreConstructorParameter=true」なのでチェックされない public SomeClass(String testField) { } // OK 「ignoreFormat」に設定の値と合致する変数名なのでチェックされない public void method(String testField) { } // OK public void method(String param) { String field = param; } // OK 「ignoreSetter=true」なのでチェックされない public void setField(String field) { this.field = field; } // 「setterCanReturnItsClass=true」なのでセッター扱いされる // OK 「ignoreSetter=true」なのでチェックされない public SomeClass setField(String testField) { this.field = field; } }
IllegalCatch
特定の例外クラスがcatch文に現れないことをチェックする。 デフォルトでは、Error, Exception, RuntimeException, Throwableがcatchに記述されている場合に検出される。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| illegalClassNames | String[] |
Error, Exception, RuntimeException, Throwable, java.lang.Error, java.lang.Exception, java.lang.RuntimeException, java.lang.Throwable | 拒否する例外クラス名 |
チェック設定例
プロパティ設定なし
<module name="IllegalCatch"/>
プロパティ設定あり
<module name="IllegalCatch"> <property name="illegalClassNames" value="IllegalArgumentException, OutOfMemoryError"/> </module>
チェック実行例
プロパティ設定なし
// NG catchにExceptionクラスを書かない try { } catch (Exception e) { } try { // OK } catch (IllegalArgumentException e) { // NG catchにRuntimeExceptionクラスを書かない } catch (RuntimeException e) { }
プロパティ設定あり
// OK try { } catch (Exception e) { } try { // NG catchにIllegalArgumentExceptionクラスを書かない } catch (IllegalArgumentException e) { // OK } catch (RuntimeException e) { }
IllegalInstantiation
ファクトリーメソッドを使用してインスタンスを作成することが望ましいものが、コンストラクタでインスタンスを作成していないかどうかをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| classes | String[] |
{} | インスタンス化しない完全修飾クラス名 |
| tokens | トークンの サブセット（CLASS_DEFのみ） | CLASS_DEF | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| CLASS_DEF | クラス宣言 |
チェック設定例
プロパティ設定なし
<module name="IllegalInstantiation"/>
プロパティ設定あり
<module name="IllegalInstantiation"> <property name="classes" value="java.lang.Boolean, java.lang.Integer"/> <property name="tokens" value="CLASS_DEF, LITERAL_NEW, PACKAGE_DEF, IMPORT"/> </module>
チェック実行例
プロパティ設定なし
プロパティの設定がない場合はチェックは実行されない。
プロパティ設定あり
// OK public class MyClass { // 独自定義したBooleanクラス public class Boolean { boolean a; public Boolean (boolean a) { this.a = a; } } public void foo(boolean a, int b) { // OK Boolean c = new Boolean(a); // NG ファクトリーメソッドを使用してインスタンスを作成するべき java.lang.Boolean d = new java.lang.Boolean(a); // NG ファクトリーメソッドを使用してインスタンスを作成するべき Integer e = new Integer(b); // OK Integer f = Integer.valueOf(b); } }
IllegalThrows
指定された例外クラスがスロー宣言されていないことをチェックする。 デフォルトではError, RuntimeException, Throwableをスロー宣言で記述すると検出される。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| illegalClassNames | String[] |
Error, RuntimeException, Throwable, java.lang.Error, java.lang.RuntimeException, java.lang.Throwable | 拒否する例外クラス名 |
| ignoredMethodNames | String[] |
finalize | チェック対象外とするメソッド名 |
| ignoreOverridden Methods | boolean | true | Override または java.lang.Override アノテーションでマークされたオーバーライドされたメソッドをチェック対象外とするかどうか |
チェック設定例
プロパティ設定なし
<module name="IllegalThrows"/>
プロパティ設定あり
<module name="IllegalThrows"> <property name="illegalClassNames" value="RuntimeException, Error"/> <property name="ignoredMethodNames" value="func1"/> <property name="ignoreOverriddenMethods" value="false"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { // NG RuntimeExceptionをスロー宣言で記述しない public void func1() throws RuntimeException {} // OK public void func2() throws Exception {} // NG Errorをスロー宣言で記述しない public void func3() throws Error {} // NG Throwableをスロー宣言で記述しない public void func4() throws Throwable {} // OK public void func5() throws NullPointerException {} // OK 「ignoreOverriddenMethods=true」なのでチェック対象外 @Override public void toString() throws Error {} }
プロパティ設定あり
public class MyClass { // OK 「ignoredMethodNames」で指定されたメソッド名と合致するのでチェック対象外 public void func1() throws RuntimeException {} // OK public void func2() throws Exception {} // NG Errorをスロー宣言で記述しない public void func3() throws Error {} // OK public void func4() throws Throwable {} // OK public void func5() throws NullPointerException {} // NG 「ignoreOverriddenMethods=false」なのでチェック対象 @Override public void toString() throws Error {} }
IllegalToken
不正なトークンが記述されていないかどうかをチェックする。 デフォルトでは、ラベルが禁止となっている。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| tokens | トークンのサブセット | LABELED_STAT | 拒否するトークン |
チェック設定例
プロパティ設定なし
<module name="IllegalToken"/>
プロパティ設定あり
<module name="IllegalToken"> <property name="tokens" value="LITERAL_IF"/> </module>
チェック実行例
プロパティ設定なし
public void foo() { // NG ラベルは使用しない outer: for (int i = 0; i < 5; i++) { if (i == 1) { break outer; } } }
プロパティ設定あり
public void foo() { outer: for (int i = 0; i < 5; i++) { // NG ifは使用しない if (i == 1) { break outer; } } }
IllegalTokenText
指定されたトークンのテキストが不正なパターンにマッチするかどうかをチェックする。
デフォルトではトークンは未指定なので、チェックは実行されない。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| format | Pattern | "^$" |
不正なパターンとする正規表現 |
| ignoreCase | boolean | false | マッチング時に大文字小文字を無視するかどうか |
| message | String | "" | 違反に関する通知に使用されるメッセージ |
| tokens | トークンのサブセット | empty | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| CHAR_LITERAL | 文字 |
| COMMENT_CONTENT | 一行コメントまたはブロックコメントのテキスト |
| IDENT | 識別子 |
| NUM_DOUBLE | 倍精度浮動小数点数 |
| NUM_FLOAT | 単精度浮動小数点 |
| NUM_INT | 整数 |
| NUM_LONG | 長整数 |
| STRING_LITERAL | 文字列 |
| TEXT_BLOCK_CONTENT | テキストブロック |
チェック設定例
プロパティ設定なし
<module name="IllegalTokenText"/>
プロパティ設定あり
<module name="IllegalTokenText"> <property name="tokens" value="STRING_LITERAL"/> <property name="format" value="a href"/> </module>
チェック実行例
プロパティ設定なし
プロパティに設定がない場合はチェックは実行されない。
プロパティ設定あり
public void foo() { // NG 「format」に合致する文字列は記述しない String test = "a href"; // OK String test2 = "A href"; }
IllegalType
特定のクラスやインターフェースが使用されないことをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| validateAbstract ClassNames | boolean | false | 抽象クラス名の検証を行うかどうか |
| illegalClassNames | 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 | 変数宣言、戻り値、パラメーターの型として使用しないクラス |
| legalAbstract ClassNames | String[] |
{} | 型として使用することができる抽象クラス |
| ignoredMethodNames | String[] |
getEnvironment, getInitialContext | チェック対象外とするメソッド名 |
| illegalAbstract ClassNameFormat | Pattern | "^(.*[.])?Abstract.*$" |
不正な抽象クラス名とする正規表現 |
| memberModifiers | トークンのサブセット | {} | 指定された修飾子のいずれかを持つメソッドとフィールドのみをチェックするようにする |
| 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 | パラメータ宣言 |
| PATTERN_VARIABLE_DEF | パターン変数定義 |
| RECORD_COMPONENT_DEF | レコードコンポーネント |
| RECORD_DEF | レコード宣言 |
| VARIABLE_DEF | 変数宣言 |
チェック設定例
プロパティ設定なし
<module name="IllegalType"/>
プロパティ設定あり
<module name="IllegalType"> <property name="tokens" value="METHOD_DEF"/> </module>
チェック実行例
プロパティ設定なし
// NG TreeSetをクラス宣言に使用しない public class Test extends TreeSet { // NG HashSetをメソッド宣言に使用しない public <T extends java.util.HashSet> void method() { // NG LinkedHashMapを変数宣言に使用しない LinkedHashMap<Integer, String> lhmap = new LinkedHashMap<Integer, String>(); // OK Map<Integer, String> map = new LinkedHashMap<Integer, String>(); } }
プロパティ設定あり
// OK チェック対象がメソッド宣言のみなのでOK public class Test extends TreeSet { // NG HashSetをメソッド宣言に使用しない public <T extends java.util.HashSet> void method() { // OK チェック対象がメソッド宣言のみなのでOK LinkedHashMap<Integer, String> lhmap = new LinkedHashMap<Integer, String>(); } }
他のプロパティを設定した場合のサンプルは公式ドキュメントを参照
InnerAssignment
String s = Integer.toString(i = 2)のような部分式での代入をチェックする。
プロパティ
なし
チェック設定例
<module name="InnerAssignment"/>
チェック実行例
class MyClass { void foo() { int a, b; // NG a = b = 5; // OK a = 5; b = 5; boolean someVal; // NG if文の中で代入しない if (someVal = true) { } } }
MagicNumber
マジックナンバーがないことをチェックする。
デフォルトでは、-1, 0, 1, 2 はマジックナンバーとはみなされない。
マジックナンバー：定数として定義されていない数値リテラルのこと。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| ignoreNumbers | double[] | -1, 0, 1, 2 | マジックナンバーとみなさない数値 |
| ignoreHash CodeMethod | boolean | false | hashCode メソッドのマジックナンバーをチェック対象外とするかどうか |
| ignoreAnnotation | boolean | false | アノテーション宣言のマジックナンバーをチェック対象外とするかどうか |
| ignoreField Declaration | boolean | false | フィールド宣言のマジックナンバーをチェック対象外とするかどうか |
| ignoreAnnotation ElementDefaults | boolean | true | アノテーション要素のデフォルトでマジックナンバーをチェック対象外とするかどうか |
| constantWaiver ParentToken | トークンのサブセット | ARRAY_INIT, ASSIGN, DIV, ELIST, EXPR, LITERAL_NEW, METHOD_CALL, MINUS, PLUS, STAR, TYPECAST, UNARY_MINUS, UNARY_PLUS | マジックナンバーの使用を許可するトークン |
| tokens | トークンのサブセット | NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| NUM_DOUBLE | 倍精度浮動小数点数リテラル |
| NUM_FLOAT | 単精度浮動小数点数リテラル |
| NUM_INT | 整数リテラル |
| NUM_LONG | 長整数リテラル |
チェック設定例
プロパティ設定なし
<module name="MagicNumber"/>
プロパティ設定あり
<module name="MagicNumber"> <property name="tokens" value="NUM_DOUBLE, NUM_FLOAT, NUM_INT"/> <property name="ignoreNumbers" value="0, 0.5, 1"/> <property name="ignoreFieldDeclaration" value="true"/> <property name="ignoreHashCodeMethod" value="true"/> <property name="ignoreAnnotation" value="true"/> </module>
チェック実行例
プロパティ設定なし
// NG アノテーションでマジックナンバーを使用しない @MyAnnotation(6) class MyClass { // NG フィールドでマジックナンバーを使用しない private field = 7; void foo() { // OK 「1」はマジックナンバーとみなさない int i = i + 1; // NG マジックナンバーを使用しない int j = j + 8; } // NG マジックナンバーを使用しない public int hashCode() { return 10; } }
プロパティ設定あり
// OK 「ignoreAnnotation=true」なのでチェック対象外 @MyAnnotation(6) class MyClass { // OK 「ignoreFieldDeclaration=true」なのでチェック対象外 private field = 7; void foo() { // OK 「1」はマジックナンバーとみなさない int i = i + 1; // NG マジックナンバーを使用しない int j = j + 8; } // OK 「ignoreHashCodeMethod=true」なのでチェック対象外 public int hashCode() { return 10; } }
MissingCtor
クラス (抽象クラスを除く) がコンストラクタを定義し、デフォルトのものに依存しないことをチェックする。
プロパティ
なし
チェック設定例
<module name="MissingCtor"/>
チェック実行例
// OK class MyClass { private int a; MyClass(int a) { this.a = a; } } // NG コンストラクタを明示的に定義する class InvalidExample { public void test() {} } // OK 抽象クラスのなのでチェック対象外 abstract class AbstractExample { public abstract void test() {} }
MissingSwitchDefault
switch文にdefault句があるかどうかをチェックする。
プロパティ
なし
チェック設定例
<module name="MissingSwitchDefault"/>
チェック実行例
// NG defaultがない switch (i) { case 1: break; case 2: break; } // OK switch (i) { case 1: break; case 2: break; default: break; }
ModifiedControlVariable
forループの制御変数がforブロックの内部で変更されないことをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| skipEnhanced ForLoopVariable | boolean | false | 拡張for文の変数のチェックをスキップするかどうか |
チェック設定例
プロパティ設定なし
<module name="ModifiedControlVariable"/>
プロパティ設定あり
<module name="ModifiedControlVariable"> <property name="skipEnhancedForLoopVariable" value="true"/> </module>
チェック実行例
プロパティ設定なし
// NG ループの内部で値が変更されている for(int i=0;i < 8;i++) { i++; } String args1[] = {"Coding", "block"}; // NG ループの内部で値が変更されている for (String arg: args1) { arg = arg.trim(); }
プロパティ設定あり
// NG ループの内部で値が変更されている for(int i=0;i < 8;i++) { i++; } String args1[] = {"Coding", "block"}; // OK 「skipEnhancedForLoopVariable=true」なのでチェック対象外 for (String arg: args1) { arg = arg.trim(); }
MultipleStringLiterals
1つのファイルに同じ文字列リテラルが複数回出現していないかどうかをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| allowedDuplicates | int | 1 | 警告を発生させずに許容する最大発生回数 |
| ignoreStringsRegexp | Pattern | "^""$" |
チェック対象外とする文字列（引用符付き）の正規表現 |
| ignoreOccurrence Context | トークンのサブセット | ANNOTATION | ignoredStringsRegexp にマッチしない場合でも、重複する文字列が無視されるトークン型名 |
チェック設定例
プロパティ設定なし
<module name="MultipleStringLiterals"/>
プロパティ設定あり
<module name="MultipleStringLiterals"> <property name="allowedDuplicates" value="2"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { String a = "StringContents"; String a1 = "unchecked"; // OK アノテーションは「ignoreOccurrenceContext」に指定されているためチェック対象外 @SuppressWarnings("unchecked") public void myTest() { // NG 変数aと同じ文字列 String a2 = "StringContents"; // NG 同じ文字列を2回使用している String a3 = "DoubleString" + "DoubleString"; // OK String a4 = "SingleString"; } }
プロパティ設定あり
public class MyClass { String a = "StringContents"; String a1 = "unchecked"; // OK アノテーションは「ignoreOccurrenceContext」に指定されているためチェック対象外 @SuppressWarnings("unchecked") public void myTest() { // OK 「allowedDuplicates=2」なので同じ文字列は2回まで定義可能 String a2 = "StringContents"; // OK 「allowedDuplicates=2」なので同じ文字列は2回まで定義可能 String a3 = "DoubleString" + "DoubleString"; // OK String a4 = "SingleString"; } }
MultipleVariableDeclarations
各変数宣言が独自の文, 独自の行にあることをチェックする。
プロパティ
なし
チェック設定例
<module name="MultipleVariableDeclarations"/>
チェック実行例
public class Test { public void myTest() { // OK int mid; int high; // NG 変数宣言は1行に1つとする int lower, higher; // NG 変数宣言は1つずつ独立した文とする int value, index; // NG 変数宣言は1行に1つとする int place = mid, number = high; } }
NestedForDepth
ネストされたfor文を指定された深さに制限する。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| max | int | 1 | 入れ子にするforの最大数 |
チェック設定例
プロパティ設定なし
<module name="NestedForDepth"/>
プロパティ設定あり
<module name="NestedForDepth"> <property name="max" value="2"/> </module>
チェック実行例
プロパティ設定なし
// NG 入れ子にするfor文は1つまで for(int i = 0; i < 10; i++) { for(int j = 0; j < i; j++) { for(int k = 0; k < j; k++) { } } } // OK for(int i = 0; i < 10; i++) { for(int j = 0; j < i; j++) { } }
プロパティ設定あり
// NG 「max=2」なので入れ子にするfor文は2つまで for(int i = 0; i < 10; i++) { for(int j = 0; j < i; j++) { for(int k = 0; k < j; k++) { for(int l = 0; l < k; l++) { } } } } // OK for(int i = 0; i < 10; i++) { for(int j = 0; j < i; j++) { for(int k = 0; k < j; k++) { } } }
NestedIfDepth
ネストされたif文を指定された深さに制限する。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| max | int | 1 | 入れ子にするifの最大数 |
チェック設定例
プロパティ設定なし
<module name="NestedIfDepth"/>
プロパティ設定あり
<module name="NestedIfDepth"> <property name="max" value="3"/> </module>
チェック実行例
プロパティ設定なし
// NG 入れ子にするif文は1つまで if (true) { if (true) { if (true) { } } } // OK if (true) { if (true) {} }
プロパティ設定あり
// NG「max=3」なので入れ子にするif文は3つまで if (true) { if (true) { if (true) { if (true) { if (true) { } } } } } // OK if (true) { if (true) { if (true) { if (true) {} } } }
NestedTryDepth
ネストされたtry-catch-finallyブロックを指定された深さに制限する。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| max | int | 1 | 入れ子にするtry-catchの最大数 |
チェック設定例
プロパティ設定なし
<module name="NestedTryDepth"/>
プロパティ設定あり
<module name="NestedTryDepth"> <property name="max" value="3"/> </module>
チェック実行例
プロパティ設定なし
// NG 入れ子にするtry-catchは1つまで try { try { try { } catch (Exception e) { } } catch (Exception e) { } } catch (Exception e) { } // OK try { try { } catch (Exception e) { } } catch (Exception e) { }
プロパティ設定あり
// NG「max=3」なので入れ子にするtry-catchは3つまで try { try { try { try { try { } catch (Exception e) { } } catch (Exception e) { } } catch (Exception e) { } } catch (Exception e) { } } catch (Exception e) { } // OK try { try { try { try { } catch (Exception e) { } } catch (Exception e) { } } catch (Exception e) { } } catch (Exception e) { }
NoArrayTrailingComma
配列の初期化に末尾のコンマが含まれていないことをチェックする。
プロパティ
なし
チェック設定例
<module name="NoArrayTrailingComma"/>
チェック実行例
// NG 末尾のコンマは不要 String[] foo1 = { "FOO", "BAR", }; // NG 末尾のコンマは不要 String[] foo2 = { "FOO", "BAR", }; // OK String[] foo3 = { "FOO", "BAR" }; // OK String[] foo4 = { "FOO", "BAR" };
NoClone
clone メソッドが Object クラスからオーバーライドされていないことを確認する。
プロパティ
なし
チェック設定例
<module name="NoClone"/>
チェック実行例
public class MyClass { // NG Object.cloneメソッドをオーバーライドしない public Object clone() {return null;} // NG Object.cloneメソッドをオーバーライドしない public Foo clone() {return null;} // OK public static Object clone(Object o) {return null;} // OK public static Foo clone(Foo o) {return null;} }
NoEnumTrailingComma
enumの定義に末尾のカンマが含まれていないことをチェックする。
プロパティ
なし
チェック設定例
<module name="NoEnumTrailingComma"/>
チェック実行例
// OK enum Foo1 { FOO, BAR; } // OK enum Foo2 { FOO, BAR } // NG 末尾のコンマは不要 enum Foo3 { FOO, BAR, } // NG 末尾のコンマは不要 enum Foo4 { FOO, BAR, ; }
NoFinalizer
パラメータのないメソッドfinalizerが存在しないことをチェックする。
プロパティ
なし
チェック設定例
<module name="NoFinalizer"/>
チェック実行例
public class MyClass { // NG パラメータなしfinalizer()メソッド protected void finalize() throws Throwable { try { System.out.println("overriding finalize()"); } catch (Throwable t) { throw t; } finally { super.finalize(); } } }
OneStatementPerLine
1行に1つの文しかないことをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| treatTryResources AsStatement | boolean | false | try文の中のリソースを文として扱い、独立した行で要求するかどうか |
チェック設定例
プロパティ設定なし
<module name="OneStatementPerLine"/>
プロパティ設定あり
<module name="OneStatementPerLine"> <property name="treatTryResourcesAsStatement" value="true"/> </module>
チェック実行例
プロパティ設定なし
// NG int var1; int var2;
プロパティ設定あり
OutputStream s1 = new PipedOutputStream(); OutputStream s2 = new PipedOutputStream(); // OK try (s1; s2; OutputStream s3 = new PipedOutputStream();){} // NG tryの中でリソース宣言が複数ある場合はそれぞれ改行する try (Reader r = new PipedReader(); s2; Reader s3 = new PipedReader()) {} // OK try (Reader r = new PipedReader(); s2; Reader s3 = new PipedReader()) {}
OverloadMethodsDeclarationOrder
オーバーロードされたメソッドがグループ化されているかどうかをチェックする。
プロパティ
なし
チェック設定例
<module name="OverloadMethodsDeclarationOrder"/>
チェック実行例
// OK public class MyClass { public void foo(int i) {} public void foo(String s) {} public void foo(String s, int i) {} public void foo(int i, String s) {} public void notFoo() {} } // NG notFooメソッドが間に割り込んでしまっている public class MyClass { public void foo(int i) {} public void foo(String s) {} public void notFoo() {} public void foo(int i, String s) {} public void foo(String s, int i) {} }
PackageDeclaration
クラスがパッケージ宣言を持つかどうかをチェックする。
プロパティを設定することでパッケージ名がソースファイルのディレクトリ名と一致するかどうか制御することができる。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| matchDirectory Structure | boolean | true | ディレクトリとパッケージ名の一致をチェックするかどうか |
チェック設定例
プロパティ設定なし
<module name="PackageDeclaration"/>
プロパティ設定あり
<module name="PackageDeclaration"> <property name="matchDirectoryStructure" value="false"/> </module>
チェック実行例
プロパティ設定なし
/com/puppycrawl/tools/checkstyle/checks/annotations/MyClass
// NG パッケージ名とディレクトリが合っていない package com.puppycrawl.tools.checkstyle.checks; public class MyClass extends AbstractCheck { }
プロパティ設定あり
/com/puppycrawl/tools/checkstyle/checks/annotations/MyClass
// OK 「matchDirectoryStructure=false」なのでパッケージ名とディレクトリが合致するかどうかはチェックされない package com.puppycrawl.tools.checkstyle.checks; public class MyClass extends AbstractCheck { }
ParameterAssignment
パラメータへの値の設定をしていないかチェックする。
プロパティ
なし
チェック設定例
<module name="ParameterAssignment"/>
チェック実行例
class MyClass { // NG メソッドの中でパラメータに値を設定している int methodOne(int parameter) { if (parameter <= 0 ) { throw new IllegalArgumentException("A positive value is expected"); } parameter -= 2; return parameter; } }
RequireThis
自身のクラスのインスタンス参照時に「this」が使用されていることをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| checkFields | boolean | true | フィールドへの参照をチェックするかどうか |
| checkMethods | boolean | true | メソッドへの参照をチェックするかどうか |
| validateOnly Overlapping | boolean | true | 変数や引数によるオーバーラップのみをチェックするかどうか |
チェック設定例
プロパティ設定なし
<module name="RequireThis"/>
プロパティ設定あり
<module name="RequireThis"> <property name="validateOnlyOverlapping" value="false"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { private int a; private int b; private int c; // OK public Test(int a) { // OK this.a = a; // OK 「validateOnlyOverlapping=true」なのでチェック対象外 b = 0; // OK 「validateOnlyOverlapping=true」なのでチェック対象外 foo(5); } public void foo(int c) { // NG thisが必要 c = c; } }
プロパティ設定あり
public class MyClass { private int a; private int b; private int c; public Test(int a) { // OK this.a = a; // NG thisが必要 b = 0; // NG thisが必要 foo(5); } public void foo(int c) { // NG thisが必要 c = c; } }
ReturnCount
メソッド、コンストラクタ、ラムダ式での return 文の数を制限する。
プロパティで指定されたメソッドをチェック対象外とすることができる（デフォルト：equals）。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| max | int | 2 | 非voidメソッド/ラムダにおける return 文の最大数 |
| maxForVoid | int | 1 | voidメソッド/コンストラクタ/ラムダにおけるreturn文の最大数 |
| format | Pattern | "^equals$" |
チェック対象外とするメソッドの正規表現 |
| tokens | トークンのサブセット | CTOR_DEF, METHOD_DEF, LAMBDA | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| CTOR_DEF | コンストラクタ宣言 |
| LAMBDA | ラムダ式の-> |
| METHOD_DEF | メソッド宣言 |
チェック設定例
プロパティ設定なし
<module name="ReturnCount"/>
プロパティ設定あり
<module name="ReturnCount"> <property name="max" value="1"/> <property name="maxForVoid" value="0"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { // OK public void foo() { return; } // NG voidメソッドのreturnは1回まで public void foo(int x) { if (x == 0) return; return; } // OK public int hoge(int x) { if (x < 0) return -1; return 0; } // NG 非voidメソッドのreturnは2回まで public int hoge(int x) { if (x < 0) return -1; if (x == 0) return 1; return 0; } }
プロパティ設定あり
public class MyClass { // OK public void foo() { } // NG 「maxForVoid=0」なのでvoidメソッドではreturnを記述しない public void foo(int x) { return; } // OK public int hoge(int x) { return 0; } // NG 「max=1」なので非voidメソッドのreturnは1回まで public int hoge(int x) { if (x < 0) return -1; return 0; } }
SimplifyBooleanExpression
複雑すぎる真理値表現をチェックする。
〇 検出されるコード例
if (b == true) b || true !false boolean a = q > 12 ? true : false
プロパティ
なし
チェック設定例
<module name="SimplifyBooleanExpression"/>
チェック実行例
public class MyClass { public void bar() { boolean a, b; Foo c, d, e; // NG if (!false) {}; // NG if (a == true) {}; // OK if (a == b) {}; // NG if (!(a != true)) {}; int s = 12; // NG boolean m = s > 1 ? true : false; // OK boolean f = c == null ? false : c.someMethod(); } }
SimplifyBooleanReturn
複雑すぎる boolean return 文をチェックする。
〇 検出されるコード
if (valid()) return false; else return true;
プロパティ
なし
チェック設定例
<module name="SimplifyBooleanReturn"/>
チェック実行例
public class MyClass { private boolean cond; private Foo a; private Foo b; // NG public boolean check1() { if (cond) { return true; } else { return false; } } // OK public boolean check2() { return cond; } }
StringLiteralEquality
文字列の比較に==や!=を使用していないことをチェックする。
プロパティ
なし
チェック設定例
<module name="StringLiteralEquality"/>
チェック実行例
String status = "pending"; // NG 文字列の比較に「==」を使用しない if (status == "done") {} // NG 文字列の比較に「!=」を使用しない while (status != "done") {} // OK boolean flag = (status.equals("done"));
SuperClone
オーバーライドされた clone() メソッドが super.clone() を呼び出すかどうかをチェックする。
プロパティ
なし
チェック設定例
<module name="SuperClone"/>
チェック実行例
// OK class A { public Object clone() { return super.clone(); } } // NG super.clone()を呼び出していない class B { private int b; public B clone() { B other = new B(); other.b = this.b; return other; } }
SuperFinalize
オーバーライドされたfinalize()メソッドがsuper.finalize()を呼び出すかどうかをチェックする。
プロパティ
なし
チェック設定例
<module name="SuperFinalize"/>
チェック実行例
// OK public class A { protected void finalize() throws Throwable { System.out.println("In finalize block"); super.finalize(); } } // NG super.finalize()を呼び出していない public class B { protected void finalize() throws Throwable { System.out.println("In finalize block"); } }
UnnecessaryParentheses
ステートメントや式の中で不要な括弧が使われているかどうかをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| tokens | トークンのサブセット | EXPR, IDENT, NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG, STRING_LITERAL, LITERAL_NULL, LITERAL_FALSE, LITERAL_TRUE, ASSIGN, BAND_ASSIGN, BOR_ASSIGN, BSR_ASSIGN, BXOR_ASSIGN, DIV_ASSIGN, MINUS_ASSIGN, MOD_ASSIGN, PLUS_ASSIGN, SL_ASSIGN, SR_ASSIGN, STAR_ASSIGN, LAMBDA, TEXT_BLOCK_LITERAL_BEGIN, LAND, LOR, LITERAL_INSTANCEOF, GT, LT, GE, LE, EQUAL, NOT_EQUAL, UNARY_MINUS, UNARY_PLUS, INC, DEC, LNOT, BNOT, POST_INC, POST_DEC | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| ASSIGN | = |
| BAND_ASSIGN | &= |
| BNOT | ~ |
| BOR_ASSIGN | |= |
| BSR_ASSIGN | >>>= |
| BXOR_ASSIGN | ^= |
| DEC | 前置-- |
| DIV_ASSIGN | /= |
| EQUAL | == |
| EXPR | 式 |
| GE | >= |
| GT | > |
| IDENT | 識別子 |
| INC | 前置++ |
| LAMBDA | -> |
| LAND | && |
| LE | <= |
| LITERAL_FALSE | false |
| LITERAL_INSTANCEOF | instanceof |
| LITERAL_NULL | null |
| LITERAL_TRUE | true |
| LNOT | ! |
| LOR | || |
| LT | < |
| MINUS_ASSIGN | -= |
| MOD_ASSIGN | %= |
| NOT_EQUAL | != |
| NUM_DOUBLE | 倍精度浮動小数点リテラル |
| NUM_FLOAT | 単精度浮動小数点リテラル |
| NUM_INT | 整数リテラル |
| NUM_LONG | 長整数リテラル |
| PLUS_ASSIGN | += |
| POST_DEC | 後置-- |
| POST_INC | 後置++ |
| SL_ASSIGN | <<= |
| SR_ASSIGN | >>= |
| STAR_ASSIGN | *= |
| STRING_LITERAL | 文字列 |
| TEXT_BLOCK_LITERAL_BEGIN | テキストブロック開始の''' |
| UNARY_MINUS | - |
| UNARY_PLUS | + |
チェック設定例
プロパティ設定なし
<module name="UnnecessaryParentheses"/>
プロパティ設定あり
<module name="UnnecessaryParentheses"> <property name="tokens" value="PLUS_ASSIGN"/> </module>
チェック実行例
プロパティ設定なし
public int square(int a, int b) { // NG ()不要 int square = (a * b); // NG ()不要 return (square); } int sumOfSquares = 0; // NG ()不要 for(int i = (0); i < 10; i++){ // NG ()不要 int x = (i + 1); // NG ()不要 sumOfSquares += (square(x * x)); }
プロパティ設定あり
public int square(int a, int b) { // OK チェック対象外 int square = (a * b); // OK チェック対象外 return (square); } int sumOfSquares = 0; // OK チェック対象外 for(int i = (0); i < 10; i++){ // OK チェック対象外 int x = (i + 1); // NG ()不要 sumOfSquares += (square(x * x)); }
UnnecessarySemicolonAfterOuterTypeDeclaration
型宣言の後に不要なセミコロンが使用されていないかどうか
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| tokens | トークンのサブセット | CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, RECORD_DEF | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| ANNOTATION_DEF | アノテーション宣言 |
| CLASS_DEF | クラス宣言 |
| ENUM_DEF | enum宣言 |
| INTERFACE_DEF | インターフェース宣言 |
| RECORD_DEF | レコード宣言 |
チェック設定例
プロパティ設定なし
<module name="UnnecessarySemicolonAfterOuterTypeDeclaration"/>
プロパティ設定あり
<module name="UnnecessarySemicolonAfterOuterTypeDeclaration"> <property name="tokens" value="CLASS_DEF"/> </module>
チェック実行例
プロパティ設定なし
// OK 内部クラスはチェック対象外 class A { class Nested { }; } // NG インターフェース宣言後にセミコロンは不要 interface B { };
プロパティ設定あり
// NG クラス宣言後のセミコロンは不要 class A { }; // OK インターフェースはチェック対象外 interface B { };
UnnecessarySemicolonAfterTypeMemberDeclaration
クラスのメンバー宣言の後に不要なセミコロンが使用されていないかをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| tokens | トークンのサブセット | CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, VARIABLE_DEF, ANNOTATION_FIELD_DEF, STATIC_INIT, INSTANCE_INIT, CTOR_DEF, METHOD_DEF, ENUM_CONSTANT_DEF, COMPACT_CTOR_DEF, RECORD_DEF | チェック対象のトークン |
〇トークンのサブセットには以下の値が設定可能
| 値 | 説明 |
|---|---|
| ANNOTATION_DEF | アノテーション宣言 |
| ANNOTATION_FIELD_DEF | アノテーションフィールド宣言 |
| CLASS_DEF | クラス宣言 |
| COMPACT_CTOR_DEF | デフォルトコンストラクタ |
| CTOR_DEF | コンストラクタ宣言 |
| ENUM_CONSTANT_DEF | Enum定数宣言 |
| ENUM_DEF | Enum宣言 |
| INSTANCE_INIT | インスタンスイニシャライザ |
| INTERFACE_DEF | インターフェース宣言 |
| METHOD_DEF | メソッド宣言 |
| RECORD_DEF | レコード宣言 |
| STATIC_INIT | スタティックイニシャライザ |
| VARIABLE_DEF | フィールドまたはローカル変数の宣言 |
チェック設定例
プロパティ設定なし
<module name="UnnecessarySemicolonAfterTypeMemberDeclaration"/>
プロパティ設定あり
<module name="UnnecessarySemicolonAfterTypeMemberDeclaration"> <property name="tokens" value="CTOR_DEF"/> </module>
チェック実行例
プロパティ設定なし
class MyClass { // NG 不要なセミコロン ; // NG 不要なセミコロン {}; // NG 不要なセミコロン static {}; // NG 不要なセミコロン MyClass(){}; // NG 不要なセミコロン void method() {}; // NG 過剰なセミコロン int field = 10;; // OK { ; } // OK static { ; } void anotherMethod() { // OK ; // OK if(true); } }
プロパティ設定あり
class MyClass { // OK チェック対象外 {}; // OK チェック対象外 static {}; // NG 不要なセミコロン MyClass(){}; // OK チェック対象外 void method() {}; }
UnnecessarySemicolonInEnumeration
enumの定義に不要なセミコロンがあるかどうかをチェックする。
プロパティ
なし
チェック設定例
<module name="UnnecessarySemicolonInEnumeration"/>
チェック実行例
// NG 不要なセミコロン enum One { A,B; } // NG 不要なセミコロン enum Two { A,B,; } // NG 不要なセミコロン enum Three { A,B(); } // NG 不要なセミコロン enum Four { A,B{}; } // NG 不要なセミコロン enum Five { A, B ; } // OK コンストラクタが宣言されている場合はセミコロンが必要 enum Normal { A, B, ; Normal(){} } // OK enum定数のみの場合はセミコロン不要 enum NoSemicolon { A, B }
UnnecessarySemicolonInTryWithResources
try-with-resourceの最後のリソース宣言で不要なセミコロンが使用されていないかをチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| allowWhenNoBrace AfterSemicolon | boolean | true | セミコロンと閉じ括弧が同じ行にない場合、不要なセミコロンを許容するかどうか |
チェック設定例
プロパティ設定なし
<module name="UnnecessarySemicolonInTryWithResources"/>
プロパティ設定あり
<module name="UnnecessarySemicolonInTryWithResources"> <property name="allowWhenNoBraceAfterSemicolon" value="false"/> </module>
チェック実行例
プロパティ設定なし
class MyClass { void foo() throws IOException { // NG 不要なセミコロン try(Reader r1 = new PipedReader();){} // NG 不要なセミコロン try(Reader r4 = new PipedReader();Reader r5 = new PipedReader() ;){} // OK 閉じ括弧とセミコロンが別行の場合許容される try(Reader r6 = new PipedReader(); Reader r7 = new PipedReader(); ){} } }
プロパティ設定あり
class MyClass { void foo() throws IOException { // NG 不要なセミコロン try(Reader r1 = new PipedReader();){} // NG 不要なセミコロン try(Reader r6 = new PipedReader(); Reader r7 = new PipedReader(); ){} } }
UnusedLocalVariable
使用されていないローカル変数をチェックする。
プロパティ
なし
チェック設定例
<module name="UnusedLocalVariable"/>
チェック実行例
class MyClass { int a; { // NG 使用されていない int k = 12; k++; } void method(int b) { // NG 使用されていない int a = 10; // NG 使用されていない int[] arr = {1, 2, 3}; // OK int[] anotherArr = {1}; anotherArr[0] = 4; } }
VariableDeclarationUsageDistance
変数が宣言されてから、最初に使用されるまでの距離をチェックする。
プロパティ
| プロパティ | 型 | デフォルト値 | 説明 |
|---|---|---|---|
| allowedDistance | int | 3 | 変数が宣言されてから最初に使用されるまでの距離 |
| ignoreVariable Pattern | Pattern | "" | 変数の距離計算を無視する変数の正規表現 |
| validateBetween Scopes | boolean | false | 変数の宣言から、異なるスコープで最初に使用されるまでの距離を計算できるようにするかどうか |
| ignoreFinal | boolean | true | final修飾子を持つ変数を無視するかどうか |
チェック設定例
プロパティ設定なし
<module name="VariableDeclarationUsageDistance"/>
プロパティ設定あり
<module name="VariableDeclarationUsageDistance"> <property name="allowedDistance" value="4"/> <property name="ignoreVariablePattern" value="^num$"/> <property name="validateBetweenScopes" value="true"/> <property name="ignoreFinal" value="false"/> </module>
チェック実行例
プロパティ設定なし
public class MyClass { public void foo1() { // NG 距離が4離れている int num; // OK finalな変数はチェックしない final int PI; System.out.println("Statement 1"); System.out.println("Statement 2"); System.out.println("Statement 3"); num = 1; PI = 3.14; } public void foo2() { // OK 異なるスコープで使用されているのでチェックしない int a; // OK 異なるスコープで使用されているのでチェックしない int b; // OK 異なるスコープで使用されているのでチェックしない int count = 0; { System.out.println("Inside inner scope"); a = 1; b = 2; count++; } } }
プロパティ設定あり
public class MyClass { public void foo1() { // OK プロパティによりチェック対象外 int num; // NG 距離が5離れている 「ignoreFinal=false」のためチェック対象 final int PI; System.out.println("Statement 1"); System.out.println("Statement 2"); System.out.println("Statement 3"); num = 1; System.out.println("Statement 4"); PI = 3.14; } public void foo2() { // OK int a; // OK int b; // NG 距離が離れすぎている 「validateBetweenScopes=true」のためチェック対象 int count = 0; { System.out.println("Inside inner scope1"); a = 1; b = 2; System.out.println("Inside inner scope2"); System.out.println("Inside inner scope3"); count++; } } }
