設(shè)計模式在現(xiàn)代Java中依然相關(guān)但已演進，2. 創(chuàng)建型模式因Java 8 特性更簡潔，如Builder更乾淨(jìng)、Singleton推薦用DI替代，3. 行為型模式受益於函數(shù)式編程，Strategy可用函數(shù)接口實現(xiàn)、Observer推薦反應(yīng)式流或Consumer回調(diào)，4. 結(jié)構(gòu)型模式仍適用但更輕量，Decorator可結(jié)合lambda、Adapter用於集成舊系統(tǒng)，5. 避免過度設(shè)計，優(yōu)先使用Supplier、records等現(xiàn)代特性簡化實現(xiàn)，最終目標(biāo)是以更少代碼實現(xiàn)清晰可維護的解決方案。

Design patterns in modern Java aren't just relics 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.

以上是現(xiàn)代爪哇的設(shè)計模式：一種實用的方法的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！