Square<\/code>, as shown in the following code:<\/p>\n\nsealed interface GeometricShape {}\nrecord Point ( int x,\n int y) implements GeometricShape { }\nrecord Line ( Point start,\n Point end) implements GeometricShape { }\nrecord Triangle( Point pointA,\n Point pointB,\n Point PointC) implements GeometricShape { }\nrecord Square ( Point pointA,\n Point pointB,\n Point PointC,\n Point pointD) implements GeometricShape { }<\/pre>\nNow assume you need a method that accepts an instance of GeometricShape<\/code> and returns its area. Since Point<\/code> and a Line<\/code> are considered one-dimensional shapes, they wouldn\u2019t have an area. Following is one of the ways to define such method that calculates and returns area:<\/p>\n\nint calcArea(GeometricShape figure) {\n return switch (figure) {\n case Point (int x, int y) -> 0;\n case Line (Point a, Point b) -> 0;\n case Triangle (Point a, Point b, Point c) -> areaTriangle(a, b, c);\n case Square (Point a, Point b, Point c, Point d) -> areaSquare (a, b, c, d);\n };\n}<\/pre>\nIn the previous example, the patterns int x<\/code>, int y<\/code>, Point a<\/code> and Point B<\/code> (for case label Line) remain unused as detected by IntelliJ IDEA. These could be replaced by an _<\/code>. Also, since all the record components of the case Point remain unused, it could be replaced as Point _<\/code>. This could also allow us to merge the first and second case labels. All of these steps are shown in the following gif:<\/p>\nHere\u2019s the modified code for your reference:<\/p>\n
\nint calcArea(GeometricShape figure) {\n return switch (figure) {\n case Point _, Line _ -> 0; \n case Triangle (Point a, Point b, Point c) -> areaTriangle(a, b, c);\n case Square (Point a, Point b, Point c, Point d) -> areaSquare (a, b, c, d);\n };\n}<\/pre>\nIn the preceding example, you can\u2019t delete the pattern variables even if they are unused. The code must include the cases when the instance passed to the method calcArea()<\/code> is of type Point<\/code> and Line<\/code>, so that it could return 0 for them.<\/p>\n2. Unused Patterns or variables with nested records<\/h3>\n This feature also comes in quite handy for nested records with multiple unused patterns or pattern variables, as demonstrated using the following example code:<\/p>\n
\nrecord Name (String fName, String lName) { }\nrecord PhoneNumber(String areaCode, String number) { }\nrecord Country (String countryCode, String countryName) { }\nrecord Passenger (Name name,\n PhoneNumber phoneNumber,\n Country from,\n Country destination) { }\n\npublic class GeoMaps {\n boolean checkFirstNameAndCountryCodeAgain (Object obj) {\n if (obj instanceof Passenger(Name (String fName, _),\n _,\n _,\n Country (String countryCode, _) )) {\n\n if (fName != null && countryCode != null) {\n return fName.startsWith("Simo") && countryCode.equals("PRG");\n }\n }\n return false;\n }\n}<\/pre>\nIn the preceding code, since the if condition in the method checkFirstNameAndCountryCodeAgain<\/code> uses only two pattern variables, others could be replaced using _<\/code>; it reduced the noise in the code too.<\/p>\n3. Requirements change, but you need side effects of constructs like an enhanced for-loop<\/h3>\n Below is an example of sample code that prints elements of an array to the console in an animated manner (you don\u2019t need to focus on the code logic. Just note that the local variable num<\/code> is used within the for loop via a call to System.out.println()<\/code>):<\/p>\n\n void animateArray() {\n int[] numbers = {9, 7, 3, 8, 5, 2, 5};\n int totalTimePerLine = 1000;\n int count = 0;\n\n \/\/ array element at first position is printed once, \n \/\/ second is printed twice and so on\n for (int num : numbers) {\n count++;\n\n\t \/\/ each line takes a total of \u2018totalTimePerLine\u2019 to print\n int delayPerNumber = totalTimePerLine \/ count;\n\n for (int i = 0; i < count; i++) { \n System.out.print(num); \n try {\n Thread.sleep(delayPerNumber); \n } catch (InterruptedException e) {\n System.out.println(e);\n }\n }\n\n System.out.println();\n }\n }<\/pre>\nImagine, after some time, the author of the previous code modifies it to print a fixed number, say, 0, instead of the array values. In this case, the code might no longer use the local loop variable num<\/code> and it might change to the following (showing only the changed line of code for conciseness):<\/p>\n\n void animateArray() {\n\t\/\/..code\n System.out.print(0); \/\/ Remove the only usage of the variable num\n\t\/\/..code\n }<\/pre>\nAnyone reading the method animateArray()<\/code> might not be able to know that at the first glance or read. However, the variable num<\/code> can\u2019t be deleted, because it is defined as a loop variable in the enhanced for loop.<\/p>\nShortening the variable name to n<\/code>, or using an implicit type, that is, var<\/code>, instead of num<\/code>, won\u2019t help much. A human must read a code snippet at least once to determine that a variable is unused. Time gone that would never come back!<\/p>\nAlso, it doesn\u2019t help much if you replace this enhanced for loop with the indexed loop, since the indexed loop variable wouldn\u2019t be used in the code too. In this case, the code is more interested in executing the code multiple times in a loop, rather than using the loop index. One of the simplest ways would be to announce that a variable is unused, so it could be ignored by folks reading this code.<\/p>\n
IDEs like IntelliJ IDEA were always able to determine this issue via their static code analysis (unused variables). With this new language feature, it can also suggest that you could replace an unused variable with an _. Here\u2019s a gif that shows this:<\/p>\nThe next example talks about another approach to address the issue of an unused local variable.<\/p>\n
4. Unused parameters in exception handlers; whose signature can\u2019t be modified<\/h3>\n What happens when you use a method, say, Thread.sleep()<\/code> that throws a checked exception, such as, InterruptedException<\/code>? You must either handle the exception by enclosing the call to Thread.sleep()<\/code> in an exception handler, or, add the throws<\/code> clause to the method in which Thread.sleep()<\/code> is called. In short, either you handle the exception yourself, or request the caller of this method to handle it.<\/p>\nLet\u2019s consider handling an exception via a catch handler which receives an instance of the thrown exception. Though the information passed via the exception instance is useful, imagine a developer doesn\u2019t use it, and writes their code as follows:<\/p>\n
\ntry {\n Thread.sleep(delayPerNumber);\n} catch (InterruptedException e) {\n System.out.println("Sleep mode interrupted");\n}<\/pre>\nIn this case, the local variable e<\/code> is unused. IntelliJ IDEA can determine it and suggest it to be replaced using _<\/code>. You could also use the problems window to access the issues in your code base and apply the suggestions, as shown below:<\/p>\n5. Unused auto-closeable resources in try-with-resources statements<\/h3>\n It is common to see code similar to the following which checks DB connection parameters, database server availability, or network issues (for hosted databases) by establishing a connection to a database. It logs success or warning messages, but doesn\u2019t use the Connection instance, connection<\/code>:<\/p>\n\nvoid checkConnection(String url, String user, String pwd) {\n try (Connection connection = DriverManager.getConnection(url, user, pwd)) {\n logger.info(STR."""\n DB Connection successful\n URL = \\{url}\n usr = \\{user}\n pwd = \\{pwd}""");\n } catch (SQLException e) {\n logger.warning(e.toString());\n }\n}<\/pre>\nThe preceeding code is a good candidate to replace the local variable connection<\/code> within the try-with-resources, with an underscore, as follows:<\/p>\n\nvoid checkConnection(String url, String user, String pwd) {\n try (Connection _ = DriverManager.getConnection(url, user, pwd)) {\n logger.info(STR."""\n DB Connection successful\n URL = \\{url}\n usr = \\{user}\n pwd = \\{pwd}""");\n } catch (SQLException e) {\n logger.warning(e.toString());\n }\n}<\/pre>\nWith the examples in this section, I highlighted how to address the unused local variables, patterns and variables in your code, when they can’t be dropped from your code.<\/p>\n
You could apply a similar approach to other unused local variables that are defined within methods, including constructors, instance and static initialisers, if, for or while constructs, and passed as method parameters.<\/p>\n
Now, let\u2019s walk through a few examples where unused variables could imply a code smell.<\/p>\n
When unused variables could be a code smell<\/h2>\n You might need tests or experience to determine if the unused variables should be addressed in a way other than replacing their name using an underscore, that is, _<\/code>.<\/p>\n1. Unused lambda parameter<\/h3>\n Imagine you define the following code in which one of the lambda parameters, that is, x, is used and y is not:<\/p>\n
\nBiFunction<Integer, Integer, Integer> add = (x, y) -> x + 0;<\/pre>\nThe previous code seems to be a code smell. The name of the method seems to suggest that it returns the sum of the values passed to it. In this case the corrective step should be to modify it as follows:<\/p>\n
\nBiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;<\/pre>\nThe preceding code is a simple example for demo purposes. When you refactor any code in your code, back them up using sufficient tests, so that the refactored code generates the same output.<\/p>\n
Also, the preceding code example doesn\u2019t imply that all unused method parameters are a code smell (as discussed previously in this blog post).<\/p>\n
2. Methods with multiple responsibilities<\/h3>\n As a good programming practice, a method should have a single responsibility. However, a method might not adhere to this practice. For instance, in the following code, the method generateRandomNumbers()<\/code> prints a random number to the console, before returning it:<\/p>\n\npublic class RandomNumber {\n public static void main(String[] args) {\n var randomNumber = generateRandomNumber();\n System.out.println(randomNumber);\n }\n \n public static int generateRandomNumber() {\n int random = new Random().nextInt(100);\n System.out.println(random);\n return random;\n }\n}\n<code><\/code><\/pre>\nOn execution, a user might see two outputs for the same random number, due to the two println()<\/code> method calls – one in the method generateRandomNumbers()<\/code> and the other in method main()<\/code>. What if another developer deletes the call to the println()<\/code> statement in method main()<\/code>. In this case, the local variable radomNumber<\/code> becomes unused, as follows:<\/p>\n\npublic static void main(String[] args) {\n var randomNumber = generateRandomNumber();\n}<\/pre>\nShould you replace the name of variable randomNumber using an _<\/code>? Nah! This looks like a code smell since the method generateRandomNumber()<\/code> includes code to accomplish unrelated tasks – returning a random number and printing a random number to the console. A better solution would be to refactor your code, extracting the code to print a number to another method, so that generateRandomNumber()<\/code> only generates a random number:<\/p>\nHere\u2019s the final code for your reference:<\/p>\n
\npublic class RandomNumber {\n public static void main(String[] args) {\n printNumberToConsole(generateRandomNumber());\n }\n \n public static int generateRandomNumber() {\n return new Random().nextInt(100);\n }\n\n private static void printNumberToConsole(int random) {\n System.out.println(random);\n }\n}<\/pre>\nHaving test methods to ensure that your method continues to serve their primary purpose is a good programming practice. I didn\u2019t include that part specifically since it would take the blog post in a tangent.<\/p>\n
In this blog post, I didn\u2019t cover an extensive list of use cases where an unused local variable could be a code smell.<\/p>\n
Summary<\/h2>\n As the name suggests, unnamed variables are local to a code construct, they don\u2019t have a name, and they are represented by using an underscore, that is, _<\/code>. They can\u2019t be passed to methods, or used in expressions.<\/p>\nBy replacing unused local variables in a code base with _<\/code> their intention is conveyed very clearly. It clearly communicates to anyone reading a code snippet that the variable is not used elsewhere. Until now, this intention could only be communicated via comments, which, unfortunately, all developers don\u2019t write.<\/p>\nA production feature in Java 22, you could use this feature in your production code, without any fears of it being changed in one of the future versions.<\/p>\n","protected":false},"author":921,"featured_media":453564,"comment_status":"closed","ping_status":"closed","template":"","categories":[4759,5088],"tags":[3374,155,8418,8325],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/448606"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/idea"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/921"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=448606"}],"version-history":[{"count":10,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/448606\/revisions"}],"predecessor-version":[{"id":458740,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/448606\/revisions\/458740"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media\/453564"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=448606"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=448606"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=448606"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=448606"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/03\/unused-variable-trailer.gif\")
<\/figure>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/03\/config1.png\")
<\/figure>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/03\/unused-pattern-variables1.gif\")
<\/figure>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/03\/unused-variable1.gif\")
<\/figure>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/03\/unused-variable2.gif\")
<\/figure>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/03\/unused-variable3.gif\")
<\/figure>\n