\n\n\n\/\/ Noncompliant - exception is lost \ntry { \n \/* ... *\/\n} catch (Exception e) {\n LOGGER.info(\"context\");\n}\n\/\/ Noncompliant - exception is lost (only message is preserved)\ntry { \n \/* ... *\/\n} catch (Exception e) {\n LOGGER.info(e.getMessage());\n}\n\/\/ Noncompliant - exception is lost\ntry { \n \/* ... *\/\n} catch (Exception e) {\n throw new RuntimeException(\"context\"); \n}\n<\/pre>\n<\/td>\n<\/tr>\n\n| compliant code example\ufeff<\/th>\n<\/tr>\n | \n\ntry { \n \/* ... *\/ \n} catch (Exception e) { \n LOGGER.info(e); \n}\ntry { \n \/* ... *\/\n} catch (Exception e) {\n throw new RuntimeException(e); \n}\n\ntry {\n \/* ... *\/\n} catch (RuntimeException e) {\n doSomething();\n throw e;\n} catch (Exception e) {\n \/\/ Conversion into unchecked exception is also allowed\n throw new RuntimeException(e);\n}<\/pre>\n<\/td><\/tr>\n<\/table>\n\n\n\nissue 2. <\/h4>\n\n\n\nDefine and throw a dedicated exception instead of using a generic one (7)<\/h5>\n\n\n\n – cause : Using such generic exceptions as Error<\/code>, RuntimeException<\/code>, Throwable<\/code>, and Exception<\/code> prevents calling methods from handling true, system-generated exceptions differently than application-generated errors.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic void foo(String bar) throws Throwable { \/\/ Noncompliant \n throw new RuntimeException(\"My Message\"); \/\/ Noncompliant \n}<\/pre>\n<\/td>\n<\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic void foo(String bar) { \n throw new MyOwnRuntimeException(\"My Message\"); \n}\n<\/pre>\n<\/td><\/tr><\/table>\n\n\n\nissue 3. <\/h4>\n\n\n\nUse isEmpty() to check whether the collection is empty or not. (1)<\/h5>\n\n\n\n – cause : Using Collection.size()<\/code> to test for emptiness works, but using Collection.isEmpty()<\/code> makes the code more readable and can be more performant. The time complexity of any isEmpty()<\/code> method implementation should be O(1)<\/code> whereas some implementations of size()<\/code> can be O(n)<\/code>.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif (myCollection.size() == 0) { \/\/ Noncompliant \n \/* ... *\/ \n}\n<\/pre>\n<\/td>\n<\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif (myCollection.isEmpty()) { \n \/* ... *\/ \n}\n<\/pre>\n<\/td>\n<\/tr>\n<\/table>\n\n\n\nissue 4.<\/h4>\n\n\n\nMove the “update” string literal on the left side of this string comparison.<\/h5>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nString myString = null;\nSystem.out.println(\"Equal? \" + myString.equals(\"foo\"));\n\/\/ Noncompliant; will raise a NPE\nSystem.out.println(\"Equal? \" + (myString != null && myString.equals(\"foo\"))); \n\/\/ Noncompliant; null check could be removed\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nSystem.out.println(\"Equal?\" + \"foo\".equals(myString)); \/\/ properly deals with the null case \n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 5.<\/h4>\n\n\n\nMerge this if statement with the enclosing one. (4)<\/h5>\n\n\n\n – cause : Merging collapsible if<\/code> statements increases the code’s readability.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif (file != null) { \n if (file.isFile() || file.isDirectory()) { \n \/* ... *\/ \n } \n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif (file != null && isFileOrDirectory(file)) { \n \/* ... *\/ \n} \nprivate static boolean isFileOrDirectory(File file) { \n return file.isFile() || file.isDirectory();\n}\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 6.<\/h4>\n\n\n\nRemove this unused “\ubcc0\uc218\uba85” (33)<\/h5>\n\n\n\n – cause : If a private field is declared but not used in the program, it can be considered dead code and should therefore be removed. This will improve maintainability because developers will not wonder what the variable is used for. (\uc8fc\ub85c \ub3c4\uba54\uc778 \uac1d\uccb4)<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic class MyClass {\n private int foo = 42;\n\n public int compute(int a) {\n return a * 42;\n }\n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic class MyClass {\n public int compute(int a) { \n return a * 42;\n }\n}\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 7. <\/h4>\n\n\n\nThe Cyclomatic Complexity of this method \uba54\uc18c\ub4dc\uba85. (9)<\/h5>\n\n\n\n – cause : The cyclomatic complexity of methods should not exceed a defined threshold.
Complex code can perform poorly and will in any case be difficult to understand and therefore to maintain.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n-\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n-\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 8.<\/h4>\n\n\n\nduplicated blocks of code must be removed. (3)<\/h5>\n\n\n\n – cause : An issue is created on a file as soon as there is at least one block of duplicated code on this file.<\/h6>\n\n\n\n \n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n-\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n-\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 9.<\/h4>\n\n\n\nThe type of the “input” object should be an interface such as “Map” rather than the implementation “HashMap”. (2)<\/h5>\n\n\n\n – cause : The purpose of the Java Collections API is to provide a well defined hierarchy of interfaces in order to hide implementation details.<\/h6>\n\n\n\n Implementing classes must be used to instantiate new collections, but the result of an instantiation should ideally be stored in a variable whose type is a Java Collection interface.<\/h6>\n\n\n\n\u00a0 This rule raises an issue when an implementation class:<\/h6>\n\n\n\n- is returned from a
public<\/code> method.<\/li>- is accepted as an argument to a
public<\/code> method.<\/li>- is exposed as a
public<\/code> member.<\/li><\/ul>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic class Employees { \n private HashSet<Employee> employees = new HashSet<Employee>(); \/\/ Noncompliant - \"employees\" should have type \"Set\" rather than \"HashSet\"\n\n public HashSet<Employee> getEmployees() { \/\/ Noncompliant \n return employees;\n }\n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic class Employees { \n private Set employees = new HashSet(); \/\/ Compliant\npublic Set getEmployees() { \/\/ Compliant \nreturn employees;\n }\n }\n<\/pre><\/td><\/tr>\n<\/table> \n\n\n\nissue 10.<\/h4>\n\n\n\nReduce the number of conditional operators {:num} used in the expression (maximum allowed :num). (3)<\/h5>\n\n\n\n – cause : The complexity of an expression is defined by the number of &&<\/code>, ||<\/code> and condition ? ifTrue : ifFalse<\/code> operators it contains.
A single expression’s complexity should not become too high to keep the code readable.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nWith the default threshold value of 3: \nif (((condition1 && condition2) || (condition3 && condition4)) && condition5) {\n ... \n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif ( (myFirstCondition() || mySecondCondition()) && myLastCondition()) { ... }\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 11.<\/h4>\n\n\n\nMethod has {:num} parameters, which is greater than {:num} authorized. (3)<\/h5>\n\n\n\n – cause : A long parameter list can indicate that a new structure should be created to wrap the numerous parameters or that the function is doing too many things.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nWith a maximum number of 4 parameters:\npublic void doSomething(int param1, int param2, int param3, String param4, long param5) {\n ...\n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic void doSomething(int param1, int param2, int param3, String param4) {\n ... \n}\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 12.<\/h4>\n\n\n\nRefactor this code to not nest more than 3 if\/for\/while\/switch\/try statements. (3)<\/h5>\n\n\n\n – cause : Nested if<\/code>, for<\/code>, while<\/code>, switch<\/code>, and try<\/code> statements is a key ingredient for making what’s known as “Spaghetti code”. Such code is hard to read, refactor and therefore maintain.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nWith the default threshold of 3: \nif (condition1) { \/\/ Compliant - depth = 1 \n \/* ... *\/ \n if (condition2) { \/\/ Compliant - depth = 2 \n \/* ... *\/ \n for(int i = 0; i < 10; i++) { \/\/ Compliant - depth = 3, not exceeding the limit \n \/* ... *\/ \n if (condition4) { \/\/ Noncompliant - depth = 4 \n if (condition5) { \/\/ Depth = 5, exceeding the limit, but issues are only reported on depth = 4 \n \/* ... *\/ \n} \n return; \n} } } }\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n-\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 13.<\/h4>\n\n\n\nComplete the task associated to this TODO comment. (2)<\/h5>\n\n\n\n – cause : TODO<\/code> tags are commonly used to mark places where some more code is required, but which the developer wants to implement later.
Sometimes the developer will not have the time or will simply forget to get back to that tag.
This rule is meant to track those tags, and ensure that they do not go unnoticed.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nvoid doSomething() { \/\/ TODO }\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n-\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 14. issue 15. issue 16. issue 17.<\/h4>\n\n\n\nDocument this public class. (17)
Document the parameter(s): page. (16)
Document this public interface. (5)
Document this public method. (70)
Document this public enum. (5)
Document this public constructor. (5) <\/h5>\n\n\n\n– cause : Try to imagine using the standard Java API (Collections, JDBC, IO, …) without Javadoc. It would be a nightmare, because Javadoc is the only way to understand of the contract of the API. Documenting an API with Javadoc increases the productivity of the developers consuming it.<\/h6>\n\n\n\nThe following Javadoc elements are required:<\/h6>\n\n\n\n- Parameters, using
@param parameterName<\/code>.<\/li>- Method return values, using
@return<\/code>.<\/li>- Generic types, using
@param <T><\/code>.<\/li><\/ul>\n\n\n\nThe following public methods and constructors are not taken into account by this rule:<\/h6>\n\n\n\n- Getters and setters.<\/li>
- Methods with @Override annotation.<\/li>
- Empty constructors.<\/li>
- Static constants.<\/li><\/ul>\n\n\n\n
\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n\/**\n * This is a Javadoc comment\n *\/\npublic class MyClass implements Runnable { \/\/ Noncompliant - missing '@param ' \n public static final DEFAULT_STATUS = 0; \/\/ Compliant - static constant\n private int status; \/\/ Compliant - not public \n public String message; \/\/ Noncompliant \n public MyClass() { \/\/ Noncompliant - missing documentation \n this.status = DEFAULT_STATUS;\n }\n\n public void setStatus(int status) { \/\/ Compliant - setter \n this.status = status; \n } \n\n@Override\npublic void run() { \/\/ Compliant - has @Override annotation } protected void doSomething() { \/\/ Compliant - not public } public void doSomething2(int value) { \/\/ Noncompliant } \npublic int doSomething3(int value) { \/\/ Noncompliant \n return value;\n} \n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\n\/** \n * This is a Javadoc comment \n * @param ... \n *\/\npublic class MyClass implements Runnable {\n public static final DEFAULT_STATUS = 0;\n private int status;\n \/**\n * This is a Javadoc comment\n *\/\n public String message;\n \/**\n * Class comment...\n *\/\n public MyClass() {\n this.status = DEFAULT_STATUS;\n }\n public void setStatus(int status) { \n this.status = status;\n }\n @Override\n public void run() { }\n protected void doSomething() { }\n \/**\n * @param value ... \n *\/\n public void doSomething(int value) {\n \/**\n * {@inheritDoc}\n *\/\n public int doSomething(int value) {\n return value;\n }\n }\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 18.<\/h4>\n\n\n\nImmediately return this expression instead of assigning it to the temporary variable (5)<\/h5>\n\n\n\n– cause : Declaring a variable only to immediately return or throw it is a bad practice.
Some developers argue that the practice improves code readability, because it enables them to explicitly name what is being returned. However, this variable is an internal implementation detail that is not exposed to the callers of the method. The method name should be sufficient for callers to know exactly what will be returned.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic long computeDurationInMilliseconds() {\n long duration = (((hours * 60) + minutes) * 60 + seconds ) * 1000; return duration;\n}\npublic void doSomething() {\n RuntimeException myException = new RuntimeException();\n throw myException; \n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic long computeDurationInMilliseconds() {\n return (((hours * 60) + minutes) * 60 + seconds ) * 1000 ; \n}\npublic void doSomething() {\n throw new RuntimeException(); \n}\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 19.<\/h4>\n\n\n\nDefine a constant instead of duplicating this literal “{:variable name}” {:num} times. (9)<\/h5>\n\n\n\n– cause : Duplicated string literals make the process of refactoring error-prone, since you must be sure to update all occurrences.
On the other hand, constants can be referenced from many places, but only need to be updated in a single place.<\/h6>\n\n\n\n\n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic void run() { \n prepare(\"action1\"); \/\/ Noncompliant - \"action1\" is duplicated 3 times execute(\"action1\"); release(\"action1\"); \n}\n@SuppressWarning(\"all\") \/\/ Compliant - annotations are excluded private void method1() {\n \/* ... *\/\n}\n@SuppressWarning(\"all\") \nprivate void method2() {\n \/* ... *\/\n}\npublic String method3(String a) {\n System.out.println(\"'\" + a + \"'\"); \/\/ Compliant - literal \"'\" has less than 5 characters and is excluded\n return \"\"; \/\/ Compliant - literal \"\" has less than 5 characters and is excluded \n}\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nprivate static final String ACTION_1 = \"action1\"; \/\/ Compliant \npublic void run() { \n prepare(ACTION_1); \/\/ Compliant \n execute(ACTION_1); \n release(ACTION_1); \n}\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 20.<\/h4>\n\n\n\nAt most one statement is allowed per line, but {:num} statements were found on this line. (3)<\/h5>\n\n\n\n– cause : For better readability, do not put more than one statement on a single line.<\/h6>\n\n\n\n \n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif(someCondition) doSomething();\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nif(someCondition) { doSomething(); }\n<\/pre><\/td><\/tr>\n<\/table>\n\n\n\nissue 21.<\/h4>\n\n\n\nReorder the modifiers to comply with the Java Language Specification. (22)<\/h5>\n\n\n\n– cause : The Java Language Specification recommends listing modifiers in the following order:<\/h6>\n\n\n\n1. Annotations
2. public
3. protected
4. private
5. abstract
6. static
7. final
8. transient
9. volatile
10. synchronized
11. native
12. strictfp
Not following this convention has no technical impact, but will reduce the code’s readability because most developers are used to the standard order.<\/p>\n\n\n\n \n| noncompliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\nstatic public void main(String[] args) { \/\/ Noncompliant }\n<\/pre><\/td><\/tr>\n| compliant code example\ufeff<\/th><\/tr>\n |
|---|
\n\n\npublic static void main(String[] args) { \/\/ Compliant }\n<\/pre><\/td><\/tr>\n<\/table>\n","protected":false},"excerpt":{"rendered":"sonarcube\ub294 \uc9c0\uc18d\uc801\uc73c\ub85c \ucf54\ub4dc\uc758 \ud488\uc9c8\uc744 \ub192\uc774\uace0 \uc720\uc9c0 \ubcf4\uc218\ud558\ub294\ub370 \ub3c4\uc6c0\uc744 \uc8fc\ub294 \uc815\uc801 \ubd84\uc11d \uc560\ud50c\ub9ac\ucf00\uc774\uc158\uc73c\ub85c \ubd84\uc11d \uae30\ub2a5\uc774 \ud0c1\uc6d4\ud558\uace0 \uac1c\uc120 \uc0ac\ud56d\ub3c4 \uc790\uc138\ud558\uac8c \uc548\ub0b4\ud574 \uc900\ub2e4. \uac04\ub2e8\ud558\uac8c\ub294 \ucf54\ub529 \ucee8\ubca4\uc158\ubd80\ud130 \ucf54\ub4dc\uc758 \uc7a0\uc7ac\uc801\uc778 \uc704\ud5d8 \uc0ac\ud56d\uae4c\uc9c0 \uc548\ub0b4\ud574\uc8fc\uc5b4 \uc62c\ubc14\ub978 \ucf54\ub529 \uc2b5\uad00\uacfc \ucf54\ub4dc\uc758 \ud488\uc9c8\ud5a5\uc0c1\uc5d0 \ub9ce\uc740 \ub3c4\uc6c0\uc744 \uc900\ub2e4. \ub2e4\uc6b4\ub85c\ub4dc \ubc0f \uc124\uce58https:\/\/www.sonarqube.org\/downloads\/ \uc5d0\uc11c \ub2e4\uc6b4\ub85c\ub4dc \ubc1b\uace0 \uc555\ucd95\uc744 \ud574\uc81c. issue 1. Either log or rethrow this exception (5) – cause<\/p>\n | | | | | | | | | |
| | | | | | | | | |
| | | | | | | | | | | | | | | |