Using var in Java

Many Java developers are used to just relying on the language’s type mechanism and not in the expressiveness of their code. The Java community started to speculate about it, many people thought it was a good idea and some don’t. To decide what to do and also to bring more representativity to the decision, a survey was made collecting the feelings and wishes of the community.

Java is a statically-typed language known for its verbosity and strict type checking. However, with the release of Java 10, a new feature called Local-Variable Type Inference was introduced, bringing the var keyword to the language and changing the way Java developers code. This article will explore the var keyword, illustrating its use cases and discussing its implications for Java coding practices.

Benefits of using var in Java

A new language feature introduced in the 2018 JDK 10 release, the Java var keyword performs type inference. The var reserved type name (not a Java keyword) was introduced in Java 10. Type inference is used in var keyword in which it detects automatically the datatype of a variable based on the surrounding context. The below examples explain where var is used and also where you can’t use it. In our IDE we can still see the type of var variables but not in Git repositories.

When not to use var in Java

One of my recent experience which happened at work where my manager asked, “Why are you using var keyword everywhere in your code? I gave him detailed explanation about the usage of var keyword after which he was convinced and approved my PR. Later in the code, seeing processor vs someVerySpecificProcessor as the variable name makes a lot of difference. The type will be exactly the same of the value the variable gets assigned to. On this example, the path variable is of type Path, and the stream variable is of type InputStream. Michael Brennan, in his blog post Why You Should Always Use the ‘var’ Keyword in C#, makes some compelling points.

Java Examples

In that case, having to declare the explicit types of the three variables message, path and stream is redundant. Starting with Java SE 10, you can use the var type identifier to declare a local variable. In doing so, you let the compiler decide what is the real type of the variable you create. With Java’s var keyword combined with type inference, Java programs remain strongly typed while the developer is relieved of the burden of explicitly stating the type of each variable. The var keyword enhances code flexibility during refactoring processes. When modifying code, developers often need to update type annotations manually, which can lead to errors or inconsistencies.

1. It’s important to note that while var improves readability by reducing verbosity, the type information isn’t lost – the variable still has a static type, determined at compile time.
2. The type of the var variables is still statically checked at compile time.
3. The introduction of the var keyword aims to alleviate this verbosity while maintaining Java’s strong type system.
4. As you can see the idea was well accepted, of course a lot of discussion happened in this period and finally, in 2018 the JEP-286 was included in the release of the JDK 10.
5. Starting with Java SE 10, you can use the var type identifier to declare a local variable.

I hope I was able to convince you all to start using var in your daily coding and make your code a lot cleaner and readable. Let me know your thoughts 💭 and share your feedbacks 🖊️ in the comments. Share it with your network so they can also learn something new today.

1. In the ever-evolving landscape of programming languages, Java has consistently maintained its relevance by embracing modern programming paradigms while preserving its core principles.
2. Another thing is that var works just like a short-hand for the traditional variable declaration, so once it is declared, we can’t assign a new value of a different type.
3. The var keyword allows you to declare a local variable without specifying its type.
4. Here we can see that when using var we don’t have to repeatedly declare the type of the local variable which we know is obvious.
5. Var was introduced with the purpose of serve the cleaner/better readability and NOT to amend the Type System of the Java language.
6. As organizations move away from Java 8 implementations and adopt Java 21, var will invariably become the norm.

With var, changes to the variable’s type do not necessitate modifying the declaration explicitly, reducing the chances of introducing errors. Var was introduced with the purpose of serve the cleaner/better readability and NOT to amend the Type System of the Java language. The above code is using var, it makes it easy to see and understand the variables. But to work, we need to give good descriptive names to our variables, and that is a good practice for all languages. In these examples, var replaces the explicit type declaration (String, int, ArrayList), making the code shorter and, in many cases, easier to read. Inferred type of the variable will be exactly the class, reference to the instance of which you’re assigning to the variable declared with var.

This gave me a thought that I should write a blog about this which will help the community who are still unaware of the var keyword in Java. Note that on the two previous examples, you have used var to declare a variable in a for statement and in a try-with-resources statement. Note that in all of these cases, the variable names are descriptive and the initializer is clear.

Inferred typing with var examples

Instead, it was more of a friendly change that makes Java methods easier to write, easier to read and more approachable for programmers who are new to the language. Type inference in Java happens when the JDK’s compiler, rather than the developer, assigns a data-type to a variable. At initialization, a type is going to be inferred by the compiler.

The var keyword allows a variable to be initialized without having to declare its type. The type of the variable depends on the type of the data that is being assigned to it. Var is a reserved type name, not a keyword, which means that existing code that uses var as a variable, method, or package name is not affected.

In the above example, name is inferred to be of type String, version is int, and list is ArrayList. Note that var can only be used to declare local variables inside methods, and in for-loop and try-with-resources statements. Java’s var keyword allows developers to declare local variables without specifying a data type such as int, long, String or char.

Java Array Class

The Java compiler will infer the type of the variable from its initializer. A good rule of thumb when it comes to the var keyword is that it can be used inside methods to declare local variables. I’m always surprised by how many Java developers are unaware of the fact that that you can declare local variables in Java with the var keyword. Java’s var keyword reduces the verbosity and ceremony surrounding var keyword in java the declaration of local variables, but it does not sidestep any rules about the platform’s strong typing requirements.

The use of the var keyword encourages developers to choose meaningful variable names that communicate the purpose of the variable, rather than focusing solely on the type. This shift can lead to more semantically rich code and improved code maintenance. The introduction of the Java var reserved word was not a revolutionary change that impacted how the JVM behaved.