多态实现：无源码扩展行为技巧

**多态实现：无源码下的行为扩展方法 - 适配器模式的应用** 本文深入探讨了在无法修改现有类源码的情况下，如何利用适配器模式实现多态行为。针对诸如 `Car` 和 `Computer` 等无法直接修改的类，通过创建适配器，将其包装成统一的 `Physical` 接口，从而实现以一致的方式处理不同类型的对象。这种方法有效避免了大量 `if` 语句进行类型判断，显著提升代码的解耦性和可维护性。文章详细阐述了适配器模式的具体实现，包括目标接口定义、适配器类创建以及静态工厂方法的使用，并结合实例代码演示了如何在 `PhysicalDetailsService` 服务中应用适配器模式，最终实现对不同类型对象重量的统一计算。了解并掌握适配器模式，能有效扩展现有类的功能，是提升软件设计能力的关键一步。

多态行为：在没有源码访问权限的情况下实现

本文探讨了在无法修改现有类（如 Car 和 Computer）源码的情况下，如何实现多态行为。通过引入适配器模式，将现有类包装成统一的接口，从而实现不同类型的对象以统一的方式进行处理，并避免使用大量的 if 语句进行类型判断，最终实现代码的解耦和可维护性。

在软件开发中，我们经常会遇到需要处理不同类型的对象，并对它们执行相似操作的情况。如果这些对象都实现了相同的接口或继承自相同的基类，那么就可以很方便地利用多态性来处理它们。但是，如果这些对象的源码我们无法访问或修改，就无法直接让它们实现统一的接口。这时，适配器模式就派上了用场。

适配器模式

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

具体实现

假设我们有两个类 Car 和 Computer，它们的源码我们无法修改。我们需要创建一个 PhysicalDetailsService 服务，该服务包含一个 calculateWeight 方法，用于计算 Car 和 Computer 对象的重量。由于 Car 和 Computer 没有共同的接口，我们需要使用适配器模式来解决这个问题。

1. 定义目标接口： 首先，定义一个接口 Physical，该接口声明了 getWeight 方法，用于获取对象的重量。

   interface Physical {
       int getWeight();
   }

2. 创建适配器类： 为 Car 和 Computer 分别创建适配器类 CarAdapter 和 ComputerAdapter，让它们实现 Physical 接口。

   class CarAdapter implements Physical {
       private final Car car;
   
       public CarAdapter(Car car) {
           this.car = car;
       }
   
       @Override
       public int getWeight() {
           return car.getTyreWeight() * 4 + car.getEngineWeight();
       }
   }
   
   class ComputerAdapter implements Physical {
       private final Computer computer;
   
       public ComputerAdapter(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 CarAdapter(car);
           } else if (o instanceof Computer computer) {
               return new ComputerAdapter(computer);
           } else {
               throw new IllegalArgumentException("Unsupported object type: " + o.getClass().getName());
           }
       }
   }

4. 使用适配器： 在 PhysicalDetailsService 服务中，使用 Physical 接口来处理 Car 和 Computer 对象。

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

示例代码

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 CarAdapter(car);
        } else if (o instanceof Computer computer) {
            return new ComputerAdapter(computer);
        } else {
            throw new IllegalArgumentException("Unsupported object type: " + o.getClass().getName());
        }
    }
}

class CarAdapter implements Physical {
    private final Car car;

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

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

class ComputerAdapter implements Physical {
    private final Computer computer;

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

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

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

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

        PhysicalDetailsService service = new PhysicalDetailsService();

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

注意事项

• 适配器模式可能会增加代码的复杂性，因此只有在必要时才使用。
• 适配器模式可能会影响性能，因为需要额外的适配器类来包装对象。
• 需要仔细考虑适配器的命名，以确保代码的可读性和可维护性。

总结

通过使用适配器模式，我们可以在不修改现有类源码的情况下，实现多态行为。这种方法可以有效地解耦代码，提高代码的可维护性和可扩展性。在实际开发中，可以根据具体情况选择合适的适配器模式实现方式。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~