设计模式：Java 代码指南13

在软件开发中，设计模式是可重用的解决方案，可解决常见编程问题。它们提供了一种结构化的方法来设计和实现软件，从而提高代码的可维护性、可伸缩性和可测试性。

Java 是一门面向对象的编程语言，提供了实现各种设计模式的强大功能。本文将探讨一些最流行的 Java 设计模式，并提供代码示例来演示它们的用法。

单例模式

单例模式确保一个类只有一个实例。它用于创建全局对象，例如日志记录器或数据库连接池。```java
// Singleton class
public class Singleton {
private static Singleton INSTANCE;
private Singleton() {
// ...
}
public static Singleton getInstance() {
if (INSTANCE == null) {
synchronized () {
if (INSTANCE == null) {
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
```

工厂模式

工厂模式用于创建对象而不指定确切的类。它抽象了创建过程，使其更容易向系统中添加新类。```java
// Factory interface
interface ShapeFactory {
Shape createShape(String shapeType);
}
// Concrete factory class
public class ShapeFactoryImpl implements ShapeFactory {
@Override
public Shape createShape(String shapeType) {
if (("circle")) {
return new Circle();
} else if (("square")) {
return new Square();
}
// ...
}
}
```

建造者模式

建造者模式使用多个步骤来创建一个复杂的对象。它允许我们逐步构建对象，而无需将创建过程硬编码到单个方法中。```java
// Builder interface
interface PizzaBuilder {
PizzaBuilder setSize(String size);
PizzaBuilder setCrust(String crust);
PizzaBuilder setToppings(List toppings);
Pizza build();
}
// Concrete builder class
public class PizzaBuilderImpl implements PizzaBuilder {
// ...
@Override
public Pizza build() {
// ...
return new Pizza(size, crust, toppings);
}
}
```

适配器模式

适配器模式允许不兼容的接口或类一起工作。它为一个类提供了一个包装器，使其看起来像另一个类，从而使它们能够相互通信。```java
// Adaptee class
public class LegacyDatabase {
public String getOldData() {
// ...
}
}
// Adapter class
public class DatabaseAdapter implements Database {
private LegacyDatabase legacyDatabase;
public DatabaseAdapter(LegacyDatabase legacyDatabase) {
= legacyDatabase;
}
@Override
public String getData() {
return ();
}
}
```

装饰器模式

装饰器模式为对象动态添加功能，而无需更改其基类。它允许我们扩展类而不破坏开放/封闭原则。```java
// Decorator interface
interface ShapeDecorator {
String draw();
}
// Concrete decorator class
public class ColorDecorator implements ShapeDecorator {
private Shape shape;
private String color;
public ColorDecorator(Shape shape, String color) {
= shape;
= color;
}
@Override
public String draw() {
return () + " with color " + color;
}
}
```

代理模式

代理模式为另一个对象提供一个代理或替代。它控制对目标对象的访问，并可以出于多种目的，例如访问控制、性能优化或懒加载。```java
// Subject interface
interface Database {
String getData();
}
// Concrete subject class
public class RealDatabase implements Database {
@Override
public String getData() {
// ...
}
}
// Proxy class
public class DatabaseProxy implements Database {
private Database realDatabase;
public DatabaseProxy(Database realDatabase) {
= realDatabase;
}
@Override
public String getData() {
// Access control or other operations can be performed here before delegating to the real database.
return ();
}
}
```

观察者模式

观察者模式定义了一对一的关系，其中一个对象（主题）维护一个依赖对象的列表，当主题状态改变时通知这些依赖对象。```java
// Subject interface
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers();
}
// Concrete subject class
public class WeatherData implements Subject {
// ...
public void measurementsChanged() {
notifyObservers();
}
}
// Observer interface
interface Observer {
void update();
}
// Concrete observer class
public class WeatherDisplay implements Observer {
// ...
@Override
public void update() {
// Display the weather data
}
}
```

策略模式

策略模式定义了一系列算法，允许我们动态切换算法，而无需更改客户端代码。它将算法的实现与使用算法的代码分离。```java
// Strategy interface
interface PaymentStrategy {
void pay(int amount);
}
// Concrete strategy class
public class CreditCardStrategy implements PaymentStrategy {
@Override
public void pay(int amount) {
// ...
}
}
// Concrete strategy class
public class PayPalStrategy implements PaymentStrategy {
@Override
public void pay(int amount) {
// ...
}
}
// Context class
public class ShoppingCart {
private PaymentStrategy paymentStrategy;
public ShoppingCart(PaymentStrategy paymentStrategy) {
= paymentStrategy;
}
public void checkout() {
(getTotalAmount());
}
}
```