无源码多态实现：适配器模式详解

还在为无法修改源码的老旧类实现多态而烦恼吗？本文为你带来**无源码适配器模式**的解决方案，教你如何通过适配器模式，优雅地将现有类包装成统一接口，实现多态行为，告别冗长的if语句！文章深入剖析适配器模式的实现步骤，提供详实的示例代码，助你理解如何在实际项目中运用该模式，有效提高代码的可维护性和可扩展性。尤其是在处理第三方库或无法直接修改源码的对象时，该模式能够完美解决接口不兼容问题，让你的代码更加简洁高效。掌握**适配器模式**，提升你的代码设计能力，打造更健壮的应用！

本文探讨了在无法修改现有类源码的情况下，如何实现多态行为。通过适配器模式，将现有类包装成统一接口，使得服务可以以多态的方式处理不同类型的对象。文章详细介绍了适配器模式的实现方式，并提供了示例代码，帮助读者理解如何在实际项目中应用该模式，从而避免使用大量的 if 语句进行类型判断，提高代码的可维护性和可扩展性。

在软件开发中，经常会遇到需要对不同类型的对象进行统一处理的情况，而这些对象的类型可能来自于第三方库，或者由于其他原因无法直接修改其源码。这种情况下，如何实现多态行为，避免大量的类型判断，是一个值得探讨的问题。本文将介绍一种基于适配器模式的解决方案。

适配器模式

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户希望的另一个接口。适配器使得原本由于接口不兼容而不能一起工作的类可以一起工作。

在本文的场景中，Car 和 Computer 类代表了需要处理的不同类型的对象，而 PhysicalDetailsService 和 PriceService 代表了需要对这些对象进行操作的服务。由于无法修改 Car 和 Computer 类的源码，无法直接让它们实现一个统一的接口，因此可以使用适配器模式。

实现步骤

1. 定义目标接口: 首先，定义一个目标接口，该接口定义了服务需要调用的方法。例如，可以定义一个名为 Physical 的接口，其中包含一个 getWeight() 方法：

interface Physical {
  int getWeight();
}

2. 创建适配器类: 为每个需要适配的类创建一个适配器类，该类实现目标接口，并在内部持有被适配类的实例。适配器类负责将被适配类的接口转换为目标接口。例如，可以创建 CarWrapper 和 ComputerWrapper 类，分别适配 Car 和 Computer 类：

class CarWrapper implements Physical {
  private final Car car;

  public CarWrapper(Car car) {
    this.car = car;
  }

  @Override
  public int getWeight() {
    return car.getTyreWeight() * 4 + car.getEngineWeight();
  }
}

class ComputerWrapper implements Physical {
  private final Computer computer;

  public ComputerWrapper(Computer computer) {
    this.computer = computer;
  }

  @Override
  public int getWeight() {
    return computer.getProcessorWeight() + computer.getCasingWeight() + computer.getPowerBankWeight();
  }
}

3. 创建工厂方法 (可选): 为了方便创建适配器实例，可以创建一个工厂方法，根据传入的对象类型，返回相应的适配器实例：

interface Physical {
  int getWeight();

  static Physical wrap(Object o) {
    if (o instanceof Car car) {
      return new CarWrapper(car);
    } else if (o instanceof Computer computer) {
      return new ComputerWrapper(computer);
    } else {
      throw new IllegalArgumentException("Unsupported type: " + o.getClass().getName());
    }
  }
}

4. 使用适配器: 在服务中使用适配器，通过调用目标接口的方法来操作对象：

public class PhysicalDetailsService {
  public int calculateWeight(Object object) {
    Physical physical = Physical.wrap(object);
    return physical.getWeight();
  }
}

示例代码

以下是一个完整的示例代码：

// 假设 Car 和 Computer 类无法修改
class Car {
  private int tyreWeight;
  private int engineWeight;

  public Car(int tyreWeight, int engineWeight) {
    this.tyreWeight = tyreWeight;
    this.engineWeight = engineWeight;
  }

  public int getTyreWeight() {
    return tyreWeight;
  }

  public int getEngineWeight() {
    return engineWeight;
  }
}

class Computer {
  private int processorWeight;
  private int casingWeight;
  private int powerBankWeight;

  public Computer(int processorWeight, int casingWeight, int powerBankWeight) {
    this.processorWeight = processorWeight;
    this.casingWeight = casingWeight;
    this.powerBankWeight = powerBankWeight;
  }

  public int getProcessorWeight() {
    return processorWeight;
  }

  public int getCasingWeight() {
    return casingWeight;
  }

  public int getPowerBankWeight() {
    return powerBankWeight;
  }
}

interface Physical {
  int getWeight();

  static Physical wrap(Object o) {
    if (o instanceof Car car) {
      return new CarWrapper(car);
    } else if (o instanceof Computer computer) {
      return new ComputerWrapper(computer);
    } else {
      throw new IllegalArgumentException("Unsupported type: " + o.getClass().getName());
    }
  }
}

class CarWrapper implements Physical {
  private final Car car;

  public CarWrapper(Car car) {
    this.car = car;
  }

  @Override
  public int getWeight() {
    return car.getTyreWeight() * 4 + car.getEngineWeight();
  }
}

class ComputerWrapper implements Physical {
  private final Computer computer;

  public ComputerWrapper(Computer computer) {
    this.computer = computer;
  }

  @Override
  public int getWeight() {
    return computer.getProcessorWeight() + computer.getCasingWeight() + computer.getPowerBankWeight();
  }
}

public class PhysicalDetailsService {
  public int calculateWeight(Object object) {
    Physical physical = Physical.wrap(object);
    return physical.getWeight();
  }

  public static void main(String[] args) {
    Car car = new Car(10, 50);
    Computer computer = new Computer(5, 10, 2);

    PhysicalDetailsService service = new PhysicalDetailsService();
    System.out.println("Car weight: " + service.calculateWeight(car));
    System.out.println("Computer weight: " + service.calculateWeight(computer));
  }
}

注意事项

• 适配器模式适用于需要将现有类适配到新的接口，或者需要将多个类的接口统一的情况。
• 适配器模式可以避免大量的类型判断，提高代码的可维护性和可扩展性。
• 在创建适配器类时，需要仔细考虑如何将被适配类的接口转换为目标接口，确保转换的正确性。
• 工厂方法可以简化适配器实例的创建过程，提高代码的可读性。

总结

通过使用适配器模式，可以在无法修改现有类源码的情况下，实现多态行为，避免大量的类型判断，提高代码的可维护性和可扩展性。该模式在实际项目中应用广泛，可以有效地解决接口不兼容的问题。

Spring Bean 配置 (补充)

虽然问题中提到了 Spring Bean 的配置，但由于缺乏具体的需求描述，这里仅提供一个通用的配置思路。 可以将 PhysicalDetailsService, CarWrapper, ComputerWrapper 等类声明为 Spring Bean，并通过依赖注入的方式将 Car 和 Computer 的实例注入到对应的 Wrapper 中。 然后，将 Wrapper 注入到 PhysicalDetailsService 中。 具体配置方式取决于你使用的 Spring 配置方式 (XML, 注解, JavaConfig)。 关键在于，确保 Spring 能够正确地创建和管理这些 Bean 之间的依赖关系。

今天关于《无源码多态实现：适配器模式详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！