Design patterns are still related but have evolved in modern Java. 2. Creative patterns are more concise due to Java 8 features, such as Builder is cleaner, Singleton recommends to replace them with DI, 3. Behavioral patterns benefit from functional programming, Strategy can be implemented using functional interfaces, Observer recommends reactive streams or Consumer callbacks, 4. Structural patterns are still applicable but lighter, Decorator can be used to integrate old systems with lambda and Adapter, 5. Avoid over-design, and prioritize the use of modern features such as Supplier and records to simplify the implementation. The ultimate goal is to implement a clear and maintainable solution with less code.

Design patterns in modern Java aren't just religions from the early 2000s—they're still relevant, but how we use them has evolved. With features like lambdas, streams, and functional interfaces introduced in Java 8 and beyond, many classic patterns have simpler, cleaner implementations or are even obsolete. Here's a practical look at how design patterns fit into modern Java development.

1. Creational Patterns: Simpler Than Ever

Creational patterns help manage object creation logic. In modern Java, some of these are streamlined thanks to language enhancements.

Builder Pattern (Still Useful, Now Cleaner)

The Builder pattern is widely used for constructing complex objects, especially immutable ones. With modern Java, you can make it more concise.

 public class User {
    private final String name;
    private final int age;
    private final String email;

    private User(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.email = builder.email;
    }

    public static class Builder {
        private String name;
        private int age;
        private String email;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

Usage:

 User user = new User.Builder()
    .name("Alice")
    .age(30)
    .email("alice@example.com")
    .build();

Tip : Use records (Java 14 ) for simple data carriers—no need for builders unless you need validation or optional fields.

Singleton Pattern (Use with Caution)

While still seen in legacy code, the Singleton pattern is often discouraged due to testability and concurrency issues.

A thread-safe, lazy-loaded version:

 public class DatabaseConnection {
    private static volatile DatabaseConnection instance;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnection.class) {
                if (instance == null) {
                    instance = new DatabaseConnection();
                }
            }
        }
        return instance;
    }
}

Modern alternative : Use dependency injection (Spring, Dagger) instead. Let the container manage single instances.

2. Behavioral Patterns: Functional Programming to the Rescue

Modern Java's functional features reduce boilerplate in behavioral patterns.

Strategy Pattern (Now Just a Functional Interface)

Instead of defining multiple classes for strategies, use Function , Predicate , or custom functional interfaces.

 @FunctionalInterface
interface DiscountStrategy {
    double applyDiscount(double amount);
}

// Usage
DiscountStrategy regular = amount -> amount * 0.9;
DiscountStrategy premium = amount -> amount * 0.7;

double finalPrice = premium.applyDiscount(100);

This eliminates the need for interface implementations and makes the code more flexible and testable.

Observer Pattern (Use Reactive Streams or Listeners)

Instead of rolling your own observer setup, leverage modern libraries:

• Java's PropertyChangeListener (for GUIs)
• Project Reactor or RxJava for event-driven flows
• Or simple callbacks with Consumer<T>

 List<Consumer<String>> listeners = new ArrayList<>();

public void onEvent(String event) {
    listeners.forEach(consumer -> consumer.accept(event));
}

// Subscribe
listeners.add(System.out::println);

For complex async flows, go reactive. For simple cases, lambdas work fine.

3. Structural Patterns: Still Relevant, But Leaner

These help structure classes and objects for better flexibility.

Decorator Pattern (Enhanced with Lambdas)

Commonly used in I/O streams (eg, BufferedInputStream wraps FileInputStream ).

You can apply it functionally:

 @FunctionalInterface
interface DataService {
    String fetchData();

    default DataService withLogging(DataService ds) {
        return () -> {
            System.out.println("Fetching data...");
            return ds.fetchData();
        };
    }
}

But prefer composition over complex hierarchies. Modern design favors small, composable components.

Adapter Pattern (Use for Integration)

When integrating with legacy or third-party APIs, the adapter pattern shines.

 class WeatherService {
    public String getWeather() {
        return "Sunny";
    }
}

interface ForecastService {
    String getCurrentForecast();
}

class WeatherAdapter implements ForecastService {
    private WeatherService service;

    public WeatherAdapter(WeatherService service) {
        this.service = service;
    }

    @Override
    public String getCurrentForecast() {
        return "Forecast: " service.getWeather();
    }
}

Use case : Wrapping old APIs to fit modern interfaces—still very practical.

4. When Not to Use Design Patterns

• Overengineering : Don't force a pattern where a simple method or lambda suffices.
• Premature abstraction : Wait until duplication or complexity emerges.
• Using patterns just because : If your team doesn't need it, skip it.

Example : Instead of a full Factory Method pattern, consider a Supplier<T> :

 Map<String, Supplier<Report>> factories = Map.of(
    "PDF", PdfReport::new,
    "CSV", CsvReport::new
);

Report report = factories.get("PDF").get();

Clean, readable, and functional.

Final Thoughts

Design patterns aren't obsolete—they've just matured. Modern Java gives us tools to implement them more elegantly:

• Use lambdas and functional interfaces to simplify behavioral patterns.
• Prefer composition and DI over rigid inheritance.
• Leverage records and var for cleaner data structures.
• Reach for reactive programming instead of manual observer setups.

The goal isn't to memorize patterns—it's to solve problems clearly and maintainably. With modern Java, you can do that with less code and better readability.

Basically: know the patterns, but don't be a slave to them.

The above is the detailed content of Design Patterns in Modern Java: A Practical Approach. For more information, please follow other related articles on the PHP Chinese website!