2.2 Creating and Storing VAR Objects (Instantiation)

In Java, the process of creating objects from classes is known as instantiation, and each created object is an instance of its class. Objects are the runtime entities that represent the state and behavior defined by their class. While Java does not have a built-in var keyword for object instantiation in the same way that dynamically typed languages do, Java 10 introduced the var keyword to infer the type of local variables, simplifying code without explicitly declaring the variable’s type.

Using `var` for Local Variable Type Inference

The var keyword allows you to declare local variables without specifying their type. The type is inferred by the compiler based on the context of its initialization. It’s important to note that var can only be used for local variables inside methods or initializers; it cannot be used for fields, method parameters, or return types.

Example Without `var`:

java

Car myCar = new Car();

Example With `var` (Java 10+):

java

var myCar = new Car();

In both examples, myCar is an object of the Car class. The second example uses var to infer the Car type from the right side of the assignment.

Advantages of Using `var`

Readability: Reduces clutter in complex generic types without compromising code readability.
Simplicity: Simplifies the declaration of variables with long or complex types.
Maintainability: When refactoring or changing the type, you only need to change the assignment part, not the variable declaration.

Guidelines for Using `var`

Initialization: Variables declared with var must be initialized.
Null Values: Cannot infer type from null. Avoid var obj = null;.
Literals: When using literals, the inferred type is the base type (e.g., int for integers, double for floating-point numbers).
Scope: Use var for local variables where the type is evident from the right-hand side of the assignment.
Readability: Avoid using var if the type is not clear, as it can make the code harder to understand.

Example: Instantiating Various Objects with `var`

java

public class Main {

    public static void main(String[] args) {

        var myCar = new Car(); // Infers Car type

        var myList = new ArrayList<String>(); // Infers ArrayList<String> type

        var myMap = new HashMap<Integer, String>(); // Infers HashMap<Integer, String> type
        
        //

Usage

        myList.add("Hello");

        myMap.put(1, "World");

        
        System.out.println(myList.get(0) + " " + myMap.get(1)); // Prints: Hello World

Conclusion

The introduction of var in Java 10 for local variable type inference simplifies code by reducing verbosity without sacrificing type safety. It’s a feature adopted from dynamically typed languages, providing developers with flexibility and clarity, especially when dealing with complex types. Remember, its use is limited to enhancing readability and should not compromise the understandability of the code.