从 JAVA 中的一种抽象方法中获得重载方法

Question

给定一个抽象类

public abstract class AbstractStomach {
    public abstract void consume(Food food);
}

我想要一些具有不同重载方法的具体类：

public class FruitStomach extends AbstractStomach {
    public static class Apple extends Food {}
    public static class Orange extends Food {}
    @Override
    public void consume(Apple food) {...}
    @Override
    public void consume(Orange food) {...}
}

public class MeatStomach extends AbstractStomach {
    public static class Beef extends Food {}
    @Override
    public void consume(Beef food) {...}
}

以上方法不起作用，因为它迫使我在每个具体类中也实现通用 consume(Food) 抽象方法。

但我不希望具体类实现consume(Food)，因为它们的重载变体已经解决了这一点，实际上，每个具体类应该只消耗不同和特定的食物，而不是任何食物，这样

AbstractStomach stomach = new FruitStomach();
stomach.consume(new Beef());

应该报错。

如果我删除了抽象类中的抽象方法，那么让他们扩展抽象类没有意义，因为它没有指导他们实现什么。

您如何修复上述设计，以便每个具体类都可以有其重载方法，但他们知道有一个抽象方法 consume() 可以实现但不需要实现 consume(Food)。

编辑

---

我可以在不使用重载的情况下解决上述问题，例如

public class FruitStomach extends AbstractStomach {
    public static class Apple extends Food {}
    public static class Orange extends Food {}
    @Override
    public void consume(Food food) {
        if (food instanceof Apple) {
           ...
        } else if (food instanceof Orange) {
           ...
        } else {
           // throws an error
        }
    }
}

但这不是我想要的。我想看看使用方法重载的解决方案。

Answer 1

您可以使用泛型来（部分）解决您的问题：

AbstractStomach 定义了一个类型参数T，它声明了它所使用的Food 的类型：

public abstract class AbstractStomach<T extends Food> {
    public abstract void consume(T food);
}

然后你可以声明一个食物类型Fruit和对应的FruitStomach：

public class Fruit extends Food {}
public class FruitStomach extends AbstractStomach<Fruit> {
    public static class Apple extends Fruit {}
    public static class Orange extends Fruit {}
    @Override
    public void consume(Fruit food) {}
}

以及类似的类Meat和MeatStomach：

public class Meat extends Food {}
public class MeatStomach extends AbstractStomach<Meat> {
    public static class Beef extends Meat {}
    @Override
    public void consume(Meat food) {}
}

Answer 2

要@Override 方法，您需要具有相同的返回值或子类型、名称和参数，这样您就无法更改“Orange orange”中的“Food food”。

我认为你可以做的是对你需要在具体类中的方法内处理的对象进行强制转换（或者就像你使用 instanceof 所做的那样）。或者你可以创建一个对象更好：

Food orange = new Orange();
Food apple = new Apple(); 

所以在 Orange 类中使用第一次方法覆盖，第二次在 Apple 类中使用 one 方法。

如果这不是您想要的解决方案，请发表评论，以便我尝试其他方法。

Answer 3

您面临的问题是，您的抽象方法签名要求将一个名为 Food 的超类传递给消费方法。这个抽象类的每个实现（以及它的抽象方法）都必须覆盖相同的签名。

例如

   public FruitStomach extends AbstractStomach {
    public static class Apple extends Food {}
    public static class Orange extends Food {}
    @Override
    public void consume(Food food) {
      if (food instanceof Orange) {
        Orange orange = (Orange) food;
        // do smth. with orange     
      } else{
        // so smth with food
      }
    }

   public MeatStomach extends AbstractStomach {
      public static class Beef extends Food {}
      @Override
      public void consume(Food food) {
        Beef beef = (Beef) food;
        // do smth. with beef...
      }
    }

可以工作。尽管这不是很干净的代码，并且如果您的代码正确连接在一起，您将没有编译时验证。 但正如你所说，如果你在错误的输入食物上调用了错误的 Stomach.consume() 方法，你可能会引发 ClassCastException，你可以处理它。

Answer 4

抽象类中的抽象方法不仅仅是“提供指导要实现什么”。抽象类允许您拥有可以是抽象类的任何子类的对象。也就是说，你可以有一个类似的方法

public void evaluateDigestion(AbstractStomach stomach) {
}

您可以使用任何类型的 Stomach 对象、FruitStomach 或 MeatStomach 或 DessertStomach 或其他方式调用它。在evaluateDigestion 内部，该方法可以调用stomach.consume(someKindOfFood)。因为这是为抽象类定义的consume（在编译时，evaluateDigestion 不知道该类是什么），所以consume 使用了Food 参数。然后，在运行时，对consume 的调用将“分派”到为具体类定义的consume(Food food) 方法。这就是为什么必须为每个具体类定义带有Food 参数的consume 的原因。调度调用不搜索带Apple、Orange等参数的重载方法； Java 不这样做。 （所以你说它“已经被重载变体照顾”是不正确的；重载和覆盖之间有很大的区别，这可能会让新手感到困惑。）

所以你必须写

public void consume(Food food)

在每个具体类中。 非常笨重的实现方式是

public void consume(Food food) {
    if (food instanceof Apple) {
        consume((Apple)food);  // calls the overloaded version because you've use a cast to tell Java how to view the object
    } else if (food instanceof Orange) {
        consume((Orange)food);
    } else {
        throw ... // some exception that occurs when you try to eat the wrong kind of food
    }
}

最好在Food 中定义一个抽象方法，假设Food 是抽象的：

public abstract class Food {
    public void abstract consumedBy(AbstractStomach stomach);
}

在Apple和Orange等类中定义具体版本，然后写consume之类的

public static void consume(Food food) {
    food.consumedBy(this);
}

但是，这不会阻止尝试让 FruitStomach 食用牛肉。您可能必须使用instanceof 来确保食物兼容。 （一种可能性：定义一个扩展Food 的类Fruit，并创建Apple 和Orange 的子类Fruit；然后你可以说food instanceof Fruit 来验证它是正确的食物种类。可能不过，这是比这更好的设计模式。我想不出一个临时的。）

Answer 5

The above doesn't work as it is forcing me to implement also the generic consume(Food)

这是正确的行为。通过抽象类AbstractStomach中的约定，您同意，

任何扩展AbstractStomach 的东西都会有一个方法 consume(Food) (any food) 然后在子类中你是 强迫它只有两种类型的食物，从而绕过合同。