Java var Keyword Explained — Local Type Inference in Java 10

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class VarWithObjects {

    // A simple class representing an order in an e-commerce system.
    static class Order {
        private final int orderId;
        private final String customerName;
        private final double totalAmount;
        private final LocalDate orderDate;

        Order(int orderId, String customerName, double totalAmount) {
            this.orderId = orderId;
            this.customerName = customerName;
            this.totalAmount = totalAmount;
            this.orderDate = LocalDate.now(); // today's date
        }

        // Returns an Optional — caller must handle the case where name is missing.
        Optional<String> getCustomerName() {
            return Optional.ofNullable(customerName);
        }

        double getTotalAmount() { return totalAmount; }
        int getOrderId()        { return orderId; }
        LocalDate getOrderDate(){ return orderDate; }

        @Override
        public String toString() {
            return "Order{id=" + orderId + ", customer='" + customerName + "', total=$" + totalAmount + "}";
        }
    }

    // A helper method that returns a list of orders.
    static List<Order> fetchRecentOrders() {
        var orders = new ArrayList<Order>(); // var: inferred as ArrayList<Order>
        orders.add(new Order(1001, "Alice Martin", 149.99));
        orders.add(new Order(1002, "Bob Chen",    89.50));
        orders.add(new Order(1003, "Sara Lopez",  220.00));
        return orders;
    }

    public static void main(String[] args) {

        // var captures the return type of fetchRecentOrders() — which is List<Order>.
        // No need to write 'List<Order>' twice.
        var recentOrders = fetchRecentOrders();

        System.out.println("=== Recent Orders ===");

        // var in the for loop: 'currentOrder' is inferred as Order
        for (var currentOrder : recentOrders) {

            // var captures the return type of getCustomerName() — which is Optional<String>
            var maybeName = currentOrder.getCustomerName();

            // var for a simple String built by orElse()
            var displayName = maybeName.orElse("Unknown Customer");

            // var for LocalDate — no more writing LocalDate twice
            var placedOn = currentOrder.getOrderDate();

            System.out.printf("  [#%d] %-15s $%.2f  (placed: %s)%n",
                currentOrder.getOrderId(),
                displayName,
                currentOrder.getTotalAmount(),
                placedOn);
        }

        // var for a running total — inferred as double
        var grandTotal = recentOrders.stream()
                                     .mapToDouble(Order::getTotalAmount)
                                     .sum();

        System.out.printf("%n  Grand Total: $%.2f%n", grandTotal);
    }
}

import java.util.*;
import java.io.BufferedReader;
import java.io.StringReader;

public class VarReadabilityComparison {

    public static void main(String[] args) throws Exception {

        // ✅ GOOD USE of var — type is crystal clear from the right-hand side.
        // The word 'BufferedReader' would appear twice without var.
        var csvReader = new BufferedReader(new StringReader("id,name,price\n1,Keyboard,49.99"));

        // ✅ GOOD USE of var — long generic type, constructor makes it obvious.
        var inventoryByCategory = new HashMap<String, List<String>>();
        inventoryByCategory.put("Electronics", new ArrayList<>(Arrays.asList("Keyboard", "Monitor")));
        inventoryByCategory.put("Furniture",   new ArrayList<>(Arrays.asList("Desk", "Chair")));

        // ✅ GOOD USE of var in a for-each — 'entry' is clearly Map.Entry<String, List<String>>
        for (var entry : inventoryByCategory.entrySet()) {
            System.out.println("Category: " + entry.getKey() + " -> " + entry.getValue());
        }

        System.out.println();

        // ⚠️  QUESTIONABLE use of var — what type does 'result' hold?
        // A reader has to go find the getInventorySummary() signature.
        // In a real project, prefer writing the explicit return type here.
        var summary = getInventorySummary(inventoryByCategory);
        System.out.println("Summary: " + summary);

        // ❌ MISLEADING use of var — is this int? long? float? double?
        // A reader might assume int; it's actually long because of the L suffix.
        // Explicit type is clearer: long warehouseCapacity = 1_000_000L;
        var warehouseCapacity = 1_000_000L;
        System.out.println("Capacity type : " + ((Object) warehouseCapacity).getClass().getSimpleName());
        System.out.println("Capacity value: " + warehouseCapacity);

        // Skip first header line and print the data line.
        var headerLine = csvReader.readLine(); // inferred: String
        var dataLine   = csvReader.readLine(); // inferred: String
        System.out.println("\nCSV Header : " + headerLine);
        System.out.println("CSV Data   : " + dataLine);
        csvReader.close();
    }

    // Notice: return type is explicit here — var cannot be used for method return types.
    static String getInventorySummary(Map<String, List<String>> inventory) {
        var totalItems = inventory.values().stream()
                                  .mapToInt(List::size)
                                  .sum(); // inferred: int
        return totalItems + " items across " + inventory.size() + " categories";
    }
}