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

// io.thecodeforge — java tutorial

public class ReservedTypeName {
    // Legal but confusing — var as a variable name
    public static void main(String[] args) {
        int var = 42;                    // 'var' is a plain identifier here
        var message = "Hello, Java 10"; // 'var' is a reserved type name here
        
        System.out.println(var);
        System.out.println(message);
    }
}

// io.thecodeforge — java tutorial

public class IllegalVarUsage {
    // Compile error: 'var' is not allowed here
    // var field = "won't compile";   

    // Also fails: 'var' not allowed for parameters
    // public void method(var param) { }

    // Return type? Denied.
    // public var returnVar() { return null; }

    public void legalVarUsage() {
        var local = "this works";  // only legal usage
        
        for (var i = 0; i < 3; i++) {
            System.out.println(i);
        }
        
        try (var scanner = new java.util.Scanner(System.in)) {
            // try-with-resources is fine
        } catch (Exception e) {
            // 'var' not allowed here: var ex = e;
        }
    }
}

// io.thecodeforge — java tutorial

import java.util.function.*;

public class LambdaInferenceFail {
    public static void main(String[] args) {
        // Compile error: cannot infer type
        // var doubler = x -> x * 2;

        // Fix 1: cast to target type
        var doubler = (IntUnaryOperator) x -> x * 2;
        System.out.println(doubler.applyAsInt(5));

        // Fix 2: typed variable (no var)
        IntUnaryOperator typedDoubler = x -> x * 2;
        System.out.println(typedDoubler.applyAsInt(10));

        // Method reference also fails without context
        // var parser = Integer::parseInt; // compile error
        var parser = (Function<String, Integer>) Integer::parseInt;
        System.out.println(parser.apply("42"));
    }
}

// io.thecodeforge — java tutorial

interface Processor {
    String process(String input);
}

public class AnonymousClassVar {
    public static void main(String[] args) {
        // Compiles, but obj is typed as anonymous class, not Processor
        var obj = new Processor() {
            @Override
            public String process(String input) {
                return input.trim().toUpperCase();
            }
        };
        
        // Works here, but hidden from readers
        System.out.println(obj.process("  hello  "));
    }
}

// io.thecodeforge — java tutorial

import java.util.ArrayList;
import java.util.List;

public class DiamondVarTrap {
    public static void main(String[] args) {
        // Both compile — but one is wrong
        var list = new ArrayList<>();
        list.add("hello");
        list.add(42);           // No compile error — list is ArrayList<Object>
        
        // This is what you actually want
        var safeList = new ArrayList<String>();
        safeList.add("hello");  // OK
        // safeList.add(42);     // Compile error — good!
        
        System.out.println(list.get(0) + " " + list.get(1));
        System.out.println(safeList.get(0));
    }
}

// io.thecodeforge — java tutorial

import java.util.*;

public class LimitationsDemo {
    public static void main(String[] args) {
        var list = new ArrayList<String>(); // inferred as ArrayList, not List
        // list = new LinkedList<String>(); // compile error: incompatible types
        
        // var noInit; // won't compile
        
        // var lambda = () -> "hello"; // won't compile — target type missing
        
        List<String> explicit = new ArrayList<>(); // clean alternative
        System.out.println(explicit.size());
    }
}

// io.thecodeforge — java tutorial

import java.util.function.*;

public class ReadabilityPitfall {
    public static void main(String[] args) {
        // Hard to guess: what is 'calc'?
        var calc = someFactory();
        
        // Bad: infers int (10), but logic expects long
        var timeout = 10; // 10 is int
        long correct = 10L;
        
        // Good: type is obvious
        String name = "Alice";
    }
    
    static Function<Integer, Boolean> someFactory() {
        return x -> x > 0;
    }
}

// io.thecodeforge — java tutorial
// Demonstrating var in a balanced, readable pattern
import java.util.*;

public class VarConclusion {
    public static void main(String[] args) {
        // var shines here: right-hand side clearly reveals type
        var order = new Order("A100", 299.99);
        var customer = new Customer("Jane Doe", "jane@example.com");
        
        // var with streams reduces noise
        var discount = order.calculateDiscount() 
            .orElse(0.0);
            
        // Avoid var when type is ambiguous:
        // var result = getValue(); // BAD — what type?
        System.out.printf("Customer: %s | Order: %s | Discount: %.2f%n",
            customer.name(), order.id(), discount);
    }
}

record Order(String id, double amount) {
    Optional<Double> calculateDiscount() {
        return amount > 100 ? Optional.of(amount * 0.1) : Optional.empty();
    }
}

record Customer(String name, String email) {}