避免使用多个if-else语句

Question

Item是带有子类别Potion, Weapon. Shield的抽象类Potion, Weapon. Shield Potion, Weapon. Shield 。

useItem()方法是在Item's每个子类中定义的抽象方法

类Item get_item返回对象

getItem方法返回Item子类的对象

case "use":
    if (hero.get_item() instanceof Potion) {
        hero.<Potion>getItem(Potion.class).useItem();

    } else if (hero.get_item() instanceof Weapon) {
        hero.<Weapon>getItem(Weapon.class).useItem();

    } else if (hero.get_item() instanceof Shield) {
        hero.<Shield>getItem(Shield.class).useItem();
    }
    break;

有没有一种方法可以将这段代码压缩为类似...

Class itemclass = hero.getItem().getClass();
hero.<itemclass>getItem(itemclass.class).useItem();

上面的代码无法编译，但是我正在寻找类似的东西。 我试图避免if else语句，因为还有更多的项目。

编辑：

我最初不使用hero.get_item().useItem()原因是因为我试图这样做

Weapon sword = hero.get_item();

这样我就可以访问诸如sword.getDamage()

但是，我将收到错误error: incompatible types: Item cannot be converted to a Weapon

所以这就是为什么我创建hero.<Weapon>getItem(Weapon.class) （来自@marsouf的帮助）的原因hero.<Weapon>getItem(Weapon.class)

今天，我创建了方法abstract public void useItem(); 并且因为它是Item类的方法，所以我可以使用hero.getItem().useItem()

Answer 1

使用useItem()方法useItem() Item的Interface会更有意义。

然后为Potion ， Shield等实现。

这样，您就不必进行强制转换并使它变得比实际更复杂。

useItem()没有提供任何功能，则它不属于抽象类，并且现在不需要的地方也可以包含default方法。

Answer 2

我的想法是在不强制转换的情况下使用泛型的魔力

public class Character<T extends Item> {
    private T item;

    public Character (T item){
        this.item = item;
    }

    public T getItem(){
       return item;
    }
}

创建英雄时：

Character hero = new Character<Weapon>(new Weapon("sword"));

之后，您可以像这样使用它：

hero.getItem().useItem(); // abstract method from Item class
hero.getItem().getPower(); //where power is a Weapon method

可以扩展的字符类如下：

public class Hero<T> extend Character<T>{
  //add there your custom methods or override Character methods
}

Answer 3

在不涉及合同的情况下很难回答（hero.get_item（），hero.getItem（））。

但是您是否尝试过：

Class<?> itemClass = hero.get_item().getClass();
hero.getItem(itemClass).useIt();

？

Answer 4

假设您已按照使用泛型的方式来使用泛型...这就是方法。

首先，我创建了一些非常简单的类来模仿您和其他问题的结构：一个使用特定抽象类实例的类。

public class ACOne extends AbstractClass
{
    @Override
    public void use(){System.out.println("Used item ACOne!");}
}
public class ACTwo extends AbstractClass
{
    @Override
    public void use(){System.out.println("Used item ACTwo!");}
}
public abstract class AbstractClass
{
    public abstract void use();
}
public class UserClass
{
    private AbstractClass item;
    public UserClass (AbstractClass item)
    {
        this.item = item;
    }
    public Class<? extends AbstractClass> getItemClass()
    {
        return item.getClass();
    }
    public <T extends AbstractClass> T getItem (Class <? extends T> targetType)
    {
        return targetType.cast(this.item);
    }
    public void setItem (AbstractClass item)
    {
        this.item = item;
    }
}
public class CastingSubclasses
{
    public void testCastingSubclasses()
    {
        UserClass user = new UserClass(new ACOne());
        user.setItem(new ACTwo());
        user.getItem(user.getItemClass()).use();
    }
}

该程序在运行时会打印出“二手ACTwo！”。

关键是在UserClass（您的Character类）的getItemClass方法中。 而且，通常会调用这些获得Class对象“ getClazz”的方法，因为有一个您不想覆盖的默认方法“ getClass”。 在这里只保留拼写是有意义的。