Question

我有2个几乎完全相同的类，理想情况下应该共享相同的父类，但不要（因为它们来自单独的库，其源代码我无法更改）。

为了举例说明，我有两个类，如：

public class Cat {
    public void speak() {
        System.out.println("Meow");
    }

    public CatFood findFood() {
        return new CatFood();
    }

    public void eat(CatFood food) {
        System.out.println("[Cat] Yum yum");
    }
}

public class Dog {
    public void speak() {
        System.out.println("Woof");
    }

    public DogFood findFood() {
        return new DogFood();
    }

    public void eat(DogFood food) {
        System.out.println("[Dog] Yum yum");
    }
}

现在理想情况下，我想做一些事情：

Animal[] animals = {new Cat(), new Dog()};
for (Animal animal : animals) {
    animal.speak();
    animal.eat(animal.findFood());
}

但 Cat和Dog不会继承Animal ，我无法更改其源代码。我还想避免依赖instanceof作为拐杖：

for (Object animal : animals) {

    if (animal instanceof Dog) {
        Dog dog = (Dog) animal;
        dog.speak();
        dog.eat(dog.findFood());

    } else if (animal instanceof Cat) {
        Cat cat = (Cat) animal;
        cat.speak();
        cat.eat(cat.findFood());

    } else if (animal instanceof Rabbit) { // etc etc
}

代码重复了几十万次，所以如果我对逻辑进行一些小改动，我也必须复制和粘贴数十万次。

那么如何以最少的代码重复使用这些类呢？

Answer 1

您可以使用适配器模式，但需要为每种类型的动物实现具体的适配器：

interface Animal {
    void speak();
    void eat();
}

class DogAdapter implements Animal {
    private Dog dog;

    public DogAdapter(Dog dog) {
        this.dog = dog;
    }

    public void speak() {
        dog.speak();
    }

    public void eat() {
        dog.eat(dog.findFood());
    }
}

class CatAdapter implements Animal {
    private Cat cat;

    public CatAdapter(Cat cat) {
        this.cat = cat;
    }

    public void speak() {
        cat.speak();
    }

    public void eat() {
        cat.eat(cat.findFood());
    }
}

使用工厂可能会封装具体创作：

class AnimalFactory {
    public static Animal createAdapter(Dog dog) {
        return new DogAdapter(dog);
    }

    public static Animal createAdapter(Cat cat) {
        return new CatAdapter(cat);
    }
}

然后你可以使用适配器并在循环中运行：

Animal[] animals = {AnimalFactory.createAdapter(cat), AnimalFactory.createAdapter(dog)};

for (Animal animal : animals) {
    animal.speak();
    animal.eat();
}

一个痛点是方法eat()，因为DogFood，CatFood，......也没有普通的超级类型。

Answer 2

如果您无法修改这些类，并且希望将代码保持在最低限度，则可以使用反射来调用这些方法。类似的东西：

Method method = obj.getClass().getMethod("speak");
method.invoke(obj);

但是考虑使用反射作为最后的手段

如何使用不共享同一父类的两个几乎相同的类？

2 个答案: