Title

默认

建议

描述

Cast to a concrete class

接口引用指向实现类

Chain of instance checks

在一串if else中，连续判断一个对象instance of某个类，比较少见

Class references one of its subclasses

父类引用指向子类对象

Collection declared by class,not interface

声明集合左边是接口

Feature envy

当一个类的方法调用另一个类的方法三次或更多次时发生

'instance of' a concrete class

warning

instance of一般判断是否是一个接口或者抽象类的实例

'instance of' check for this

error　

使用this肯定知道是哪个Class

interface method clashes with method in 'java.lang.Object'

warning

error

接口定义的方法名和Object的方法冲突，如clone方法

Local variable of a concrete class

在类的方法里创建本类的实例对象

Magic number

warning

不允许任何魔法值(即未经定义的常量)直接出现在代码中 ，参考阿里规范

Method parameter of a concrete class

方法参数不允许有实体类，比较常见

Method return of a concrete class

方法return实体类，比较常见

'Optional' used as field or parameter type

warning

error

java.util.Optional一般用作防空指针，定义成成员变量或者参数比较奇怪

Overly strong type cast

warning

高强强制类型转换，有时候我们强转List即可却强转成ArrayList

Private method only used from inner class

私有方法仅在内部类使用，那么可以挪到内部类中

Public method not exposed in interface

public方法没有定义在接口中

Public method with 'boolean' parameter

public方法有boolean类型参数

Static field of concrete class

静态成员变量定义在实体类中

Static method only used from one other class

静态方法只在另外某个类中使用

Type may be weakened

声明变量可以用List的时候不要用ArrayList

Type of instance field is concrete class

成员变量是实体类，常见

Title

默认

建议

描述

Assignment replaceable with operator assignment

赋值操作可以用赋值运算符代替

Assignment to for 'loop' parameter

warning

在for循环中改变了循环的参数

Assignment to catch block parameter

对try代码块的参数赋值

Assignment to lambda parameter

对lambda表达式中的参数进行赋值

Assignment to method parameter

对方法参数赋值

Assignment to static field from instance context

在实例方法中对静态成员赋值

Assignment used as condition

把赋值作为if、for、for或do语句的条件

Constructor assigns value to field defined in superclass

warning

在构造方法中对父类成员变量赋值，这样做不合理，应该调用父类构造方法

'null' assignment

赋值null，很多时候会用到

Result of assignment used

赋值表达式结果被使用

Value of ++ or -- used

嵌套在其他表达式中的增量或减量表达式

Title

默认

建议

描述

Anonymous inner class has too many methods　

匿名内部类方法过多（默认限制1)

Class too deep in inheritance tree

类的继承过于复杂（默认限制2层）

Class with too many constructors

warning

类的构造方法过多（默认限制5个）

Class with too many fields

类的成员变量过多（默认限制10个）

Class with too many methods

类的方法过多（默认限制20个）

Inner class too deeply nested

内部类中含有内部类

Overly complex anonymous class

匿名类过于复杂

Overly complex class

类过于复杂

Overly coupled class

类refer的类过多

Title

默认

建议

描述

Abstract class may be interface

No highlighting,only fix

warning

抽象类可以定义成接口

Anonymous inner class

使用匿名内部类

Class may extend adaptor instead of implementing listener

可以继承适配器代替实现监听器

Class name differs from file name

warning

类名和文件名不同

Class with only private constructors should be defined final

只有私有构造方法的类无法被继承

Constant declared in abstract class

常量定义在抽象类里

Constant declared in interface

常量定义在接口中

Empty class

空类

Field can be local

warning

成员变量可以声明成final的

'final' class

class声明为final的

'final' method

method声明为final的

'final' method in 'final' class

在final class中定义final method

inner class of interface

接口中定义内部类

interface may be annotated as @FunctionalInterface

@FunctionalInterface：这个注解表示一个函数式接口元素。函数式接口是一种只有一个抽象方法（非默认）的接口。编译器会检查被注解元素，如果不符，就会产生错误。

Limited-scope inner class

Reports any limited-scope inner classes.Some code standards discourage the use of limited-scope inner classes, and they are unusual enough as to possibly be confusing.

Marker interface

空接口做标记用，在hibernate validator中常见

Method returns per-class constant

方法只返回常量

Multiple top level classes in single final

一个java文件中有多个顶级类

No-op method in abstract class

warning

抽象类中的空方法没有被声明成abstract，比较少见

Non-'final' field in enum

枚举的field没有加上final描述

Non-'static' initializer

Reports any non-static initializers in classes.Some coding standards prohibit instance initializers, preferring initialization to be done in constructors or field initializers.Non-static initializers may also be inadvertently created by deleting the static keyword, resulting in obscure bugs.This inspection does not warn on instance initializers in anonymous classes. 

Parameter can be local

warning

参数可以声明成局部变量

'private' method declared final

warning

error

私有方法被声明成final的了，冗余

'protected' member in final class

warning

定义成final的类无法被继承，protected的使用不正确

'public' constructor

public构造方法，正常

'public' constructor in non public class

非public类中有public构造方法

Singleton

使用了单例

'static' method declared final

warning

error

静态方法被定义成final，无意义

'static',non 'final' field

静态变量未定义成final

Utility class

所有字段和方法都是static的类

Utility class can be 'enum'

Utility class可以改造成枚举

Utility class is not final

Utility class未被定义成final的

Utility class with public constructor

Utility class有public构造方法

Utility class without private constructor

Utility class没有private构造方法

Title

默认

建议

描述

Call to printStackTrace()

error

成熟的代码应该使用log

Call to Thread.dumpStack

warning

静态dumpstack()方法提供一个new exception ("stack trace").printstacktrace ()的封装，打印一个追踪当前线程的堆栈，调试用。

Deprecated API usage

 warning

error

使用了过时的API

Deprecated member is still used

 warning

error

使用了过时的member

Inspection suppression annotation

Reports any inspection suppression comments or annotations. 

Throwable printed to system.out

 warning

error

用system.out来print异常

Usage of API marked as removal

 error

使用了被@Deprecated(forRemoval=true) 标记的方法

Use of absolute collection type

error

使用了java.util.Vector or java.util.Hashtable这些不推荐使用的类

Use of absoulte date-time API

warning

使用了java.util.Date, java.util.Calendar, java.util.GregorianCalendar, java.util.TimeZone, and java.util.SimpleTimeZone.jdk1.8推荐使用LocalDate等工具

Use of System.out or System.err

error

使用了System.out or System.err，用log替代

Title

默认

建议

描述

Array creation without new expression

No high lighting,only fix

int[] a = {42}推荐声明int[] a = new int[]{42}.

assert message is not a string

断言非string，影响不大

Blocker marker comment

warning

注释位置不合理

while (i < 10) {
i++;
} // end while参考阿里规范，写在while上方

C-style array declaration

No high lighting,only fix 

error

C语言风格的数组声明

public String process(String value[])[] {
return value;
}

Call to String.concat() can be replaced with '+'

可以用+替换concat方法

Chained equality comparisons

error

类似(i.e. a==b==c).难看

Chained method calls

链式编程，常见

Class explicitly extends java.lang.Object

warning

error

直接声明一个类继承了Object，无意义

Code block contains single statement

No high lighting,only fix

none

代码块只有一行，常见

Conditional can be replaced with Optional

No high lighting,only fix 

return str == null ? "" : str.trim();
Could be rewritten as
return Optional.ofNullable(str).map(String::trim).orElse("");

Confusing octal escape sequence

字符串中包含8进制字符序列+数字，可能会混淆

Constant expression can be evaluated

No high lighting,only fix 

none

常量不用计算式直接用算好的值，不推荐

Constant on left side of comparision 

常数放在比较表达式的左边，左右看个人喜好，推荐左边

Constant on right side of comparision 

No high lighting,only fix 

常数放在比较表达式的右边，左右看个人喜好，推荐左边

Control flow statement without braces

No high lighting,only fix 

warning

条件或者循环语句括号没打好

Diamond can be replaced with explicit type arguments

No high lighting,only fix  

none 

Example of use the diamond:

List <String> list = new ArrayList<>()
The statement above is replaced with the following:
List <String> list = new ArrayList<String>()

equals called on Enum value

对于枚举，使用equals的情况可以直接使用==

(expression).equals("literal")rather than("literal").equals(expression)

error

减少空指针的好习惯

Field assignment can be moved to initializer

No high lighting,only fix   

This intention replaces initialization of field via assignment with field initializer.

Field may be final

成员变量可以声明成final

if statement may be replaced with && or || expression

No high lighting,only fix  

none

if statements of the form if (condition) return true else return foo or if (condition) return false else return foo. These expressions may be safely simplified to return condition || foo or return !condition && foo, respectively.

Implicit call to super() 

隐式调用super

indexOf expression is replacable with contains

error

Reports any List.indexOf() expressions which can be replaced with the method List.contains(). 

Instance field access not qualified with this

使用field有时候没加this

Instantce method call not qualified with this 

使用method有时候没加this

Lambda body can be code block

No high lighting,only fix  

 none

This inspection reports lambdas which body is an expression, e.g. n -> n + 1
The quick fix converts lambda's expression body to a code block, like the following:
n -> {
return n + 1;
}

Lambda can be replaced with anonymous class

No high lighting,only fix   

none 

lambda可以换成你匿名类写法

Lambda parameter type can be specified

No high lighting,only fix   

none

This inspection reports lambda parameters which don't have their type specified, e.g. a -> a + 1
The quick fix adds type declaration to the lambda parameters, the result looks like this: (int a) -> a + 1

Local variable or parameter can be final

局部变量或者参数可以加上final修饰

Method reference can be replaced with lambda

No high lighting,only fix    

This inspection reports method references, like MyClass::myMethod and myObject::myMethod.The quick fix for the inspection replaces the method reference with an equivalent lambda expression that invokes the method.For example, the method reference System.out::println is replaced with s -> System.out.println(s)  

Missorted modifiers

error

修饰词顺序不符合规范 

Multi-catch can be splict into seperate catch blocks

No high lighting,only fix    

none

多异常multi catch可拆开

Multiple variables in one declaration

warning

一行代码声明了多个变量

nested method call

Reports method calls used as parameters of another method call. 

Null value for Optional type

warning

error

Optional本身常用来防空指针，不应为null

Optional contains array or collection

Optional get到的数据是数组或者集合，ok

Raw type can be generic

No high lighting,only fix    

warning

可以使用泛型的地方未使用

Redundant new expression in constant array creation

int[] a = new int[]{42} which can be replaced with an array initializer, e.g. int[] a = {42}

跟Array creation without new expression正好相反，不推荐

Redundant field initialization

Reports fields explicitly initialized to the same values that the JVM would initialize them to by default.

Redundant interface declaration

Reports any cases of classes declaring that they implement or extend an interface, when that interface is already declared as implemented by a superclass or extended by another interface of that class.Such declarations are unnecessary, and may be safely removed.与继承关系有关多余的接口声明

Redundant no-arg constructor

warning

多余的无参构造方法

Replace Optional.isPresent() checks with functional-style expressions

warning

none

Optional.isPresent() 可以改成函数式风格

Return of this

返回this对象，常见

Return seperated from computation of result

No high lighting,only fix    

none

感觉不怎么实用

For example, the code below could be simplified:
int n = -1;
for(int i = 0; i < a.length; i++) {
if (a[i] == b) {
n = i;
break;
}
}
return n;
After the quick fix it becomes the following:
int n = -1;
for(int i = 0; i < a.length; i++) {
if (a[i] == b) {
return i;
}
}
return n;

Simplifiable annotation

Reports annotations which can be simplified to their 'single element' or 'marker' shorthand form.Annotations that contain whitespace between the @-sign and the name of the annotation are also reported.

Single-element annotation

No high lighting,only fix    

none

这个风格感觉不怎么好，简洁好点
This inspection reports annotations in the 'single element' shorthand form, like @Retention(RUNTIME).
The quick fix for this inspection converts annotation to the 'normal' form (with attribute name), e.g. @Retention(value=RUNTIME).

size==0 replacable with isEmpty

error

很实用，判断list非空isEmpty一目了然

Stream API call chain can be replaced with loop

No high lighting,only fix    

none

可用循环代替使用stream

Subsequent steps can be fused into Stream API chain

 warning

链式编程优化Detects when some transformations are performed on Stream API result which could be incorporated into the Stream API call chain directly. E.g.:
List<String> list = stream.collect(Collectors.toList());
list.sort(null);
return list.toArray(new String[list.size()]);
Could be converted to
return stream.sorted().toArray(String[]::new);

Try statement with multiple resources can be split

No high lighting,only fix    

none

try多个操作拆分，不推荐

The quick fix suggests to split such statements into nested try-with-resources statements. Example of try statement with multiple resources:
try (FileInputStream in = new FileInputStream("in.txt");
FileOutputStream out = new FileOutputStream("out.txt")) {
/*read and write*/
}
The example above is transformed into the following:
try (FileInputStream in = new FileInputStream("in.txt")) {
try (FileOutputStream out = new FileOutputStream("out.txt")) {
/*read and write*/
}
}

Type parameter explicitly extends java.lang.Object

warning

 error

参数显式继承Object 

Unclear expression

表达式括号没打好之类 Reports binary, conditional or instanceof expressions consisting of multiple terms with different operators without parentheses. Such expressions can be unclear because not every developer is intimately familiar with all the precedence rules of the different operators. This inspection has a quickfix which adds clarifying parentheses.

Unnessarily qualified inner class access

内部类有些场景不用加上Outter.Inner使用

Unnessarily qualified static access 

本类中访问静态元素不需ClassName.

Unnessarily qualified staticly imported element

静态导入后，访问对应的静态元素不需ClassName

Unnessarily final on local variable or parameter 

与上面的Local variable or parameter can be final正好相反

Unnessarily null check before equals call

error

多余的空指针校验

Unnessarily super qualifier

多余的super.

Unnessarily this qualifier

多余的this.

Unnessarily String.valueOf()

warning

如StringBuffer.append(String.valueOf(1));

Unnessarily call to super()

默认构造方法隐式调用

Unnessarily call to toString()

如syso(StringBuffer.toString())

Unnessarily code block

No high lighting,only fix    

Reports code blocks which are unnecessary to the semantics of the program, and can be replaced by their contents. Code blocks which are the bodies of if, do, while or for statements will not be reported by this inspection. 

Unnessarily enum modifier

warning

枚举多余的修饰词

Unnessarily full qualified name

No high lighting,only fix    

可以不使用类全名的场景

Unnessarily interface modifier

warning

接口声明中多余的修饰词

Unnessarily parentheses

No high lighting,only fix    

没必要的括号

Unnessarily quelifier for this or super

Unnessarily super qualifier+Unnessarily this qualifier

Unnessarily semicolon

warning

多余的分号

Unqualified inner class access

Unnessarily qualified inner class access的反面

Unqualified static access

Unnessarily qualified static access 的反面

Variables of different types in one declaration

warning

一行声明多个不同类型的变量，String s = "", array[];

Title

默认

建议

描述

Javac quirks 

warning

javac注释不合规问题

Uncheckd warning

warning

Signals places where an unchecked warning is issued by the compiler, for example:

void f(HashMap map) { map.put("key", "value"); }

Title

默认

建议

描述

Assertation can be replaced with if statement

No high lighting,only fix    

none

This inspection looks for assert statements. For example, assert param != null;

Quick fix replaces it with if statement throwing an java.lang.AssertionError.

Example: if (param == null) throw new AssertionError();

Boolean expression could be replaced with conditional expression

warning

Boolean类型表达式优化

Reports any boolean expressions which can be expressed more compactly, and arguably more clearly, as a conditional expression. Take for example the following expression:

a && b || !a && c;

which may be expressed as:

a ? b : c;

break statement

break语句，正常

break statement with label

带标签的break语句

Conditional can be pushed inside branch expression

No high lighting,only fix    

warning

条件表达式优化

Reports conditional expressions with then and else branches so similar that the conditional expression can be pushed inside, thereby shortening the code.

For example the following conditional expression:

condition ? message("value: " + 1) : message("value: " + 2)

Can be pushed inside and transformed into:

message("value: " + (condition ? 1 : 2))

Conditional expression(?:)

No high lighting,only fix    

none

使用三元运算符

Conditional expression with identical branches

Reports conditional expressions with identical then and else branches. Such expressions are almost certainly a mistake.

Conditional expression with negated condition

warning

Reports conditional expressions of the form true?result1:result2 or false?result1:result2. These expressions sometimes occur as the result of automatic refactorings, and may obviously be simplified.

continue statement

使用continue

continue statement with label

带标签的continue语句

default not last case in switch statement

error

在switch中，default不在最后

double negation

warning

error

双重否定

Reports double negation.

For example:

if (!!functionCall())

duplicate condition in if statement

warning

if中出现了重复的条件

duplicate condition on && or ||

warning

条件重复

enum switch statement that misses case

No high lighting,only fix    

switch enum的时候漏了case

fallthrough in switch statement

warning

swich中未使用break

for loop may be replaced with while loop

No high lighting,only fix    

none

可用while循环替代for循环

for loop with missing components

Reports for loops that lack initialization, condition, or update clauses. Some coding styles prohibit such loops.

idempotent loop body

warning

error

幂等循环体，不会被结束

int suffix = 1;

String name = baseName;

while(names.contains(name)) {

name = baseName + suffix; // error: suffix is not updated making loop body idempotent

}

if statement could be replaced with conditional expression

warning

if语句可以换三元运算符

if (foo == null) {

bar = null;

} else {

bar = foo.get();

}

may be expressed as:

bar = foo == null ? null : foo.get();

if statement with common parts

if体中有重复部分

Before:

if (x > 12) {

doSomethingBefore();

doSomethingDifferent1();

doSomethingAfter();

} else {

doSomething();

doSomethingDifferent2();

doSomethingAfter();

}

After:

doSomethingBefore();

if (x > 12) {

doSomethingDifferent1();

} else {

doSomethingDifferent2();

}

doSomethingAfter();

if statement with negated condition

warning

if的条件是否定，可以调换if else顺序

if statement with too many branches

if分支过多，默认3个

infinite loop statement

warning

无限循环语句

labeled statenebt

带标签语句

local variable used and declared in different switch branches

局部变量的声明和使用在不同switch分支

loop statement that does not loop

warning

error

循环语句不会启动

loop variable not updated inside loop

warning

error

循环标记变量在循环中不改变

loop with implicit termination condition

Reports any while, do-while and for loops which have the constant true as their only condition, but which still can be terminated by a containing if statement which can break out of the loop. This if statement must be the first or only statement in a while or for loops and the last or only statement in a do-while loop. Such a loop would be clearer if the if statement was removed and its condition was made an explicit loop condition.

move condition to loop

warning

循环优化

while(true) { if(i == 23) break; i++; }

Will be replaced with:

while(i != 23) { i++; }

negated conditional expression

Reports conditional expressions which are negated with a prefix expression. For example:

!(i == 1 ? a : b)

negated equality expression

warning

!(i == 1)

nested switch statement

switch嵌套switch

nested conditional expression

三元运算符嵌套

overly complex boolean expression

boolean表达式过度复杂（默认三个以上条件）

pointless indexOf comparison

warning

indexOf>-1则无意义

pointless boolean expression

warning

无意义的boolean表达式

redundant else

No high lighting,only fix    

warning

冗余的else

redundant if statement

warning

error

多余的if

For example:

if (foo()) {

return true;

} else {

return false;

}

can be simplified to

return foo();

redundant conditional expression

warning

error

多余的三元运算符

Example Replacement

condition ? true : false condition

condition ? false : true !condition

value == null ? null : value value

result != 0 ? result : 0 result

a == b ? a : b b

simplifiable boolean expression

warning

error

boolean表达式可以简化

Reports boolean expressions of the form !(foo ^ bar) and (foo && bar) || !foo. Such expressions may be safely simplified to foo == bar and !foo || bar respectively.

simplifiable conditional expression

warning

error

可简化的三元运算符

Reports conditional expressions of the following form

condition ? true : foo

condition ? false : foo

condition ? foo : !foo

condition ? !foo : foo

These expressions may respectively be safely simplified to

condition || foo

!condition && foo

condition == foo

condition != foo

statement can be replaced with assert or Object.requireNotNull

No high lighting,only fix    

none

Reports if statements (with no else branch) throwing java.lang.Throwable. For example: if (param == 2) throw new Exception(); or guava's: Preconditions.checkNotNull(param, message)

Quick fix replaces it with an assert statement. Example: assert param != 2;

switch statement

switch语句

switch statement with too few branches

switch case太少（默认2个）

switch statement with too low of a branch density

分支密度过低

Reports switch statements with too low a ratio of switch labels to executable statements. Such switch statements may be confusing, and should probably be refactored.

switch statement with too many branches

switch case太多（默认10个）

switch statement without default branch

warning

switch缺少default

Unnessary null check before instanceof expression or call

warning

error

instanceof无需校验null

Here is an example of a violation:

if (x != null && x instanceof String) { ... }

The quickfix changes this code to:

if (x instanceof String) { ... }