3.1 Introduction To Modern Syntax

Java's syntax has evolved dramatically from its verbose origins to become one of the most expressive statically-typed languages available today. Where Java 8 required explicit types everywhere and boilerplate for simple operations, modern Java (Java 17-25) offers local variable inference, pattern matching, exhaustive switch expressions, and text blocks that dramatically reduce ceremony while maintaining type safety.

What You'll Learn

This chapter covers five major areas of modern Java syntax:

  1. Type Inference and var: Understanding when and how to use local variable inference without sacrificing clarity or maintainability
  2. Enhanced Switch Expressions: Moving from imperative switch statements to expression-oriented, exhaustive switches with pattern matching
  3. Text Blocks and String Templates: Managing multi-line strings, embedded formats (JSON/SQL/HTML), and string interpolation
  4. Pattern Matching Fundamentals: Destructuring data with instanceof, switch patterns, and record patterns
  5. Modern Control Flow: try-with-resources, enhanced for loops, and modern exception handling patterns

The Evolution: From Verbose to Expressive

Java 8 (2014): The Verbose Era

// Explicit types everywhere
Map<String, List<Integer>> inventory = new HashMap<String, List<Integer>>();

// Imperative switch requiring mutation
String description;
switch (status) {
    case ACTIVE:
        description = "Currently active";
        break;
    case PENDING:
        description = "Awaiting approval";
        break;
    default:
        description = "Unknown";
}

// Type casting with manual null checks
Object obj = fetch();
if (obj != null && obj instanceof String) {
    String s = (String) obj;

    if (!s.isEmpty()) {
        processString(s);
    }
}
// Multi-line strings with manual concatenation
String json = "{\n" +
              "  \"name\": \"Alice\",\n" +
              "  \"age\": 30\n" +
              "}";

Java 25 (2025): The Concise Era

// Type inference with var
var inventory = new HashMap<String, List<Integer>>();

// Switch expressions with exhaustiveness
var description = switch (status) {
    case ACTIVE -> "Currently active";
    case PENDING -> "Awaiting approval";
};  // Compiler enforces exhaustiveness

// Pattern matching eliminates casting
Object obj = fetch();
if (obj instanceof String s && !s.isEmpty()) {
    processString(s);
}

// Text blocks for multi-line literals
var json = """
    {
      "name": "Alice",
      "age": 30
    }
    """;

Character Count Comparison:

  • Java 8 example: ~520 characters
  • Java 25 example: ~360 characters (31% reduction)
  • More importantly: Zero loss of type safety, improved readability

Core Principles of Modern Java Syntax

1. Expression-Oriented Programming

Modern Java favors expressions (which return values) over statements (which perform actions).

Statement-oriented (old):

int result;
if (condition) {
    result = 10;
} else {
    result = 20;
}
return result;

Expression-oriented (modern):

return condition ? 10 : 20;

// Or with switch expression:
return switch (status) {
    case SUCCESS -> 10;
    case FAILURE -> 20;
};

Benefits:

  • Immutability by default: No need for mutable variables
  • Exhaustiveness: Compiler ensures all cases are handled
  • Composition: Expressions can be nested and combined

2. Pattern Matching Over Type Casting

Old approach: Test, cast, use

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase());
}

Modern approach: Match and bind

if (obj instanceof String s) {
    System.out.println(s.toUpperCase());
}

Pattern matching eliminates three problems:

  1. Redundancy: No need to repeat the type
  2. Safety: No risk of casting to the wrong type
  3. Scope: Pattern variable s only exists where it's guaranteed to be that type

3. Type Inference Where Obvious

Not inference for the sake of brevity:

var x = compute();  // Bad: What type is x?

Inference where the right-hand side is self-documenting:

var users = List.of("alice", "bob");           // Clearly List<String>
var config = new HashMap<String, Integer>();   // Clearly HashMap<String, Integer>
var file = Path.of("/data/input.txt");        // Clearly Path

Rule: Use var when it reduces noise without hiding intent.

4. Declarative Over Imperative

Imperative (how to do it):

List<String> filtered = new ArrayList<>();
for (String item : items) {
    if (item.startsWith("A")) {
        filtered.add(item);
    }
}

Declarative (what to do):

var filtered = items.stream()
    .filter(item -> item.startsWith("A"))
    .toList();

Modern syntax encourages describing what you want, not how to compute it.

5. Safety Through Exhaustiveness

Old switch (error-prone):

switch (color) {
    case RED:
        return "#FF0000";
    case GREEN:
        return "#00FF00";
    // Forgot BLUE case - compiles, returns null at runtime!
}

Modern switch (compiler-enforced):

return switch (color) {
    case RED -> "#FF0000";
    case GREEN -> "#00FF00";
    case BLUE -> "#0000FF";
};  // Must cover all cases or won't compile

With sealed types and exhaustive switches, illegal states become unrepresentable.

Why This Matters for Experienced Developers

Code Density vs. Clarity Trade-off

Modern Java syntax allows you to write 30-50% less code while maintaining or improving clarity:

Traditional approach (18 lines):

public String formatUser(Object obj) {
    if (obj == null) {
        return "Unknown";
    }

    if (obj instanceof User) {
        User user = (User) obj;
        if (user.isActive()) {
            return "Active: " + user.name();
        } else {
            return "Inactive: " + user.name();
        }
    }

    return "Not a user";
}

Modern approach (5 lines):

public String formatUser(Object obj) {
    return switch (obj) {
        case null -> "Unknown";
        case User(var name, var active) when active -> "Active: " + name;
        case User(var name, _) -> "Inactive: " + name;
        default -> "Not a user";
    };
}

Key differences:

  • 72% fewer lines
  • No mutable variables
  • Exhaustive handling of all cases
  • Pattern destructuring eliminates getters
  • Compiler verifies completeness

Maintainability Benefits

  1. Fewer bugs: Exhaustiveness checking catches missing cases at compile time
  2. Easier refactoring: Adding a new enum value forces you to handle it in all switches
  3. Self-documenting: Pattern matching makes data flow explicit
  4. Reduced cognitive load: Less code to understand means faster comprehension

Performance Considerations

Modern syntax does not sacrifice performance:

  • var is compile-time inference (zero runtime cost)
  • Switch expressions compile to efficient bytecode (tableswitch/lookupswitch)
  • Pattern matching uses the same instanceof checks as manual casting
  • Text blocks are compile-time constants (interned like regular strings)

In fact, modern constructs often improve performance by enabling better JIT optimizations.

Migration Strategy

When modernizing existing code:

  1. Start with var in local variables where types are obvious
  2. Convert imperative switches to expression form
  3. Replace concatenated strings with text blocks
  4. Add pattern matching to instanceof checks
  5. Introduce sealed types for closed hierarchies

Don't rewrite everything at once. Modern and legacy syntax coexist peacefully, allowing gradual migration.

Chapter Structure

This chapter is organized into five detailed sections:

  1. Modern Syntax Overview: Quick reference of essential modern constructs with before/after examples
  2. Type Inference Deep Dive: Complete guide to var, generic inference, and lambda type inference
  3. Enhanced Switch Expressions: Exhaustive switches, pattern matching in switch, guarded patterns, and null handling
  4. Text Blocks and Templates: Multi-line string management, indentation rules, formatting, and use cases
  5. Pattern Matching Fundamentals: instanceof patterns, record patterns, switch patterns, and advanced destructuring

Prerequisites

This chapter assumes:

  • Familiarity with Java's basic syntax (classes, methods, control flow)
  • Understanding of Java's type system (generics, inheritance, interfaces)
  • Experience with Java 8+ features (lambdas, streams, Optional)

If you're new to Java, review Part I first to establish foundational knowledge.

Conclusion

Modern Java syntax represents a fundamental shift from ceremony to clarity. By embracing type inference, pattern matching, and expression-oriented programming, you'll write code that's:

  • Shorter without being cryptic
  • Safer through compile-time exhaustiveness
  • More maintainable by eliminating boilerplate
  • More expressive while remaining statically typed

The rest of this chapter provides deep dives into each construct with practical examples, edge cases, and best practices. Let's begin with the Modern Syntax Overview.