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

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

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

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

适配器模式

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

具体实现

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

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

   interface Physical {
       int getWeight();
   }

   登录后复制

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

   

   有道小P

   有道小P，新一代AI全科学习助手，在学习中遇到任何问题都可以问我。

   64

   查看详情

   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));
    }
}

注意事项

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

总结

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

以上就是多态行为：在没有源码访问权限的情况下实现的详细内容，更多请关注php中文网其它相关文章！