Java编程实战解锁高效代码设计的五大核心模式

# Java编程实战解锁高效代码设计的五大核心模式

## 单例模式（Singleton Pattern）

单例模式确保类只有一个实例，并提供全局访问点。在Java中实现单例模式有多种方式：

```java

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;

}

}

```

双重检查锁定模式既保证了线程安全，又避免了不必要的同步开销。

## 工厂模式（Factory Pattern）

工厂模式提供创建对象的接口，让子类决定实例化哪个类：

```java

public interface Notification {

void send();

}

public class EmailNotification implements Notification {

@Override

public void send() {

System.out.println(发送邮件通知);

}

}

public class SMSNotification implements Notification {

@Override

public void send() {

System.out.println(发送短信通知);

}

}

public class NotificationFactory {

public Notification createNotification(String type) {

switch (type) {

case EMAIL:

return new EmailNotification();

case SMS:

return new SMSNotification();

default:

throw new IllegalArgumentException(未知的通知类型);

}

}

}

```

## 观察者模式（Observer Pattern）

观察者模式定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖者都会收到通知：

```java

public interface Observer {

void update(String message);

}

public interface Subject {

void registerObserver(Observer observer);

void removeObserver(Observer observer);

void notifyObservers();

}

public class NewsPublisher implements Subject {

private List observers = new ArrayList<>();

private String latestNews;

@Override

public void registerObserver(Observer observer) {

observers.add(observer);

}

@Override

public void removeObserver(Observer observer) {

observers.remove(observer);

}

@Override

public void notifyObservers() {

for (Observer observer : observers) {

observer.update(latestNews);

}

}

public void setLatestNews(String news) {

this.latestNews = news;

notifyObservers();

}

}

```

## 策略模式（Strategy Pattern）

策略模式定义一系列算法，将每个算法封装起来，使它们可以相互替换：

```java

public interface PaymentStrategy {

void pay(int amount);

}

public class CreditCardPayment implements PaymentStrategy {

private String cardNumber;

public CreditCardPayment(String cardNumber) {

this.cardNumber = cardNumber;

}

@Override

public void pay(int amount) {

System.out.println(使用信用卡支付： + amount + 元);

}

}

public class PayPalPayment implements PaymentStrategy {

private String email;

public PayPalPayment(String email) {

this.email = email;

}

@Override

public void pay(int amount) {

System.out.println(使用PayPal支付： + amount + 元);

}

}

public class ShoppingCart {

private PaymentStrategy paymentStrategy;

public void setPaymentStrategy(PaymentStrategy paymentStrategy) {

this.paymentStrategy = paymentStrategy;

}

public void checkout(int amount) {

paymentStrategy.pay(amount);

}

}

```

## 建造者模式（Builder Pattern）

建造者模式使用多个简单对象构建一个复杂对象，提供更好的可读性和灵活性：

```java

public class Computer {

private final String cpu;

private final String ram;

private final String storage;

private final String gpu;

private Computer(ComputerBuilder builder) {

this.cpu = builder.cpu;

this.ram = builder.ram;

this.storage = builder.storage;

this.gpu = builder.gpu;

}

public static class ComputerBuilder {

private String cpu;

private String ram;

private String storage;

private String gpu;

public ComputerBuilder setCpu(String cpu) {

this.cpu = cpu;

return this;

}

public ComputerBuilder setRam(String ram) {

this.ram = ram;

return this;

}

public ComputerBuilder setStorage(String storage) {

this.storage = storage;

return this;

}

public ComputerBuilder setGpu(String gpu) {

this.gpu = gpu;

return this;

}

public Computer build() {

return new Computer(this);

}

}

}

// 使用示例

Computer computer = new Computer.ComputerBuilder()

.setCpu(Intel i7)

.setRam(16GB)

.setStorage(1TB SSD)

.setGpu(NVIDIA RTX 3080)

.build();

```

这五种核心设计模式在Java编程中具有广泛应用，能够显著提升代码的可维护性、可扩展性和复用性。熟练掌握这些模式，能够帮助开发者设计出更加优雅和高效的Java应用程序。