Java var — Diamond Operator Type Safety Risk

public class VarBasicDemo {
    public static void main(String[] args) {

        // Without var — the traditional way.
        // Notice we write 'String' twice: once on the left, once implicitly through the literal.
        String productName = "Wireless Keyboard";

        // With var — the compiler sees "Wireless Keyboard", knows it's a String,
        // and treats this exactly as: String discountedName = "Mechanical Mouse";
        var discountedName = "Mechanical Mouse";

        // var works with any type the compiler can infer from the right-hand side.
        var itemCount = 42;           // inferred as int
        var itemPrice = 29.99;        // inferred as double
        var isInStock = true;         // inferred as boolean
        var firstLetter = 'K';        // inferred as char

        // Once inferred, the type is LOCKED. The line below would cause a compile error:
        // itemCount = "forty-two";  // ERROR: incompatible types: String cannot be converted to int

        System.out.println("Product : " + productName);
        System.out.println("Discount Item : " + discountedName);
        System.out.println("Count   : " + itemCount);
        System.out.println("Price   : $" + itemPrice);
        System.out.println("In Stock: " + isInStock);
        System.out.println("Initial : " + firstLetter);

        // Let's prove the type is real — getClass() returns the actual runtime type.
        System.out.println("\nRuntime type of discountedName : " + ((Object) discountedName).getClass().getSimpleName());
        System.out.println("Runtime type of itemPrice      : " + ((Object) itemPrice).getClass().getSimpleName());
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class VarScopeRules {

    // RULE 1: var is NOT allowed for class fields.
    // The line below would NOT compile — uncomment to see the error.
    // var storeId = 101;  // ERROR: 'var' is not allowed here

    public static void main(String[] args) {

        // RULE 2: var MUST have an initializer on the same line.
        // var pendingOrders;  // ERROR: cannot use 'var' on variable without initializer

        // RULE 3: var cannot be initialized to null alone —
        // the compiler can't figure out what type you want.
        // var customerName = null;  // ERROR: cannot infer type for local variable customerName

        // ✅ VALID — simple local variables
        var storeName = "TheCodeForge Shop";    // inferred: String
        var totalItems = 150;                   // inferred: int
        var taxRate = 0.08;                     // inferred: double

        // ✅ VALID — var shines with verbose generic types.
        // Old way (perfectly fine but noisy):
        Map<String, List<Integer>> categoryToProductIds = new HashMap<>();

        // New way with var — same type, same safety, half the characters:
        var categoryMap = new HashMap<String, List<Integer>>();
        // ^ inferred as: HashMap<String, List<Integer>>

        // ✅ VALID — var inside a for loop (very common real-world use)
        var productNames = new ArrayList<String>();
        productNames.add("Laptop Stand");
        productNames.add("USB Hub");
        productNames.add("Ergonomic Chair");

        // var in an enhanced for loop — 'productName' is inferred as String
        for (var productName : productNames) {
            System.out.println("  Product: " + productName.toUpperCase());
        }

        // ✅ VALID — var in a traditional for loop
        for (var index = 0; index < productNames.size(); index++) {
            System.out.println("  Index " + index + " -> " + productNames.get(index));
        }

        System.out.println("\nStore  : " + storeName);
        System.out.println("Items  : " + totalItems);
        System.out.println("Tax    : " + (taxRate * 100) + "%");
        System.out.println("Category map type: " + categoryMap.getClass().getSimpleName());
    }
}

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";
    }
}

public class VarTeamGuidelines {
    public static void main(String[] args) {

        // ✅ Allowed by team rule: constructor obvious
        var logger = new java.util.logging.Logger("MyApp", null); // inferred: Logger

        // ✅ Allowed: for-each with clear iterable type
        var names = java.util.List.of("Alice", "Bob"); // List<String>
        for (var name : names) {
            System.out.println(name.toUpperCase());
        }

        // ❌ NOT allowed by team rule: ambiguous numeric literal
        // var elapsed = 5000;     // int? long? Could be long millis.
        // Instead: long elapsed = 5000L;

        // ❌ NOT allowed by team rule: method call
        // var result = someMethod();  // reader must find method signature
        // Instead: String result = someMethod();

        // ✅ Allowed: constructor obvious, generic parameter explicit
        var orderMap = new java.util.HashMap<String, Integer>(); // HashMap<String, Integer>
        orderMap.put("ORD-001", 3);

        // ⚠️ Mixed: stream pipeline — some teams allow if final chain is short
        var total = orderMap.values().stream()
                           .mapToInt(Integer::intValue)
                           .sum(); // inferred: int
        System.out.println("Total quantity: " + total);
    }
}