Question

所以我有一个Object类Item和一个Object类Trap。这两个共享变量称为name和icon。我希望能够将这两个类放入一个名为special的数组中，并且能够使用Item访问Trap和special的组件。这是我需要工作的代码。

if (special[x][y] == null)
    return 0;
System.out.print(special[x][y].icon);    /* here's where the issue is */
return 1;

special应该是什么？我应该使用界面吗？如果是这样，怎么样？我一直在读书，但我不知道如何描述我的问题。

Answer 1

尝试一下：

class Base 
{
    String name;
    Icon icon;
}

class Item extends Base { }

class Trap extends Base { }

List<Base> special = new ArrayList<>();

或者，您可以将Base作为界面，并使用implements关键字代替extends Item和Trap。

Answer 2

可能有效的一种方法是使用超类（类，抽象类，接口所有工作）。这对于超类来说是一个坏名字，但我相信你会明白这个想法：

public class Thing {
    String icon; // Every class that extends Thing has an icon
    String name; // Every class that extends Thing has a name

    public Thing(String newIcon, String newName) {
        icon = newIcon;
        name = newName;
    }

    public String getIcon() {
        return this.icon;
    }

    public String getName() {
        return this.name;
    }
}

public class Trap extends Thing {
    public Trap() {
        super("newIcon", "newName"); // Sets this Traps's name and icon values
    }
}

public class Item extends Thing {
    public Item() {
        super("newIcon", "newName"); // Sets this Item's name and icon values
    }
}

你可以添加你想要的任何方法/变量Trap和Item，只要它们本身合法，它们就可以工作。

Answer 3

为Item和Trap创建一个界面，其中包含应分享的方法。

public interface GameObject {
    String getName();
    Image getIcon();
}

然后，您可以通过实现此接口来创建Item和Trap类。例如

public class Trap implements GameObject {
    private String name;
    private Image icon;
    public GameObject(String name, Image icon) {
        this.name = name;
        this.icon = icon;
    } ...

通过声明此类实现GameObject，这意味着我们必须创建getName和getIcon方法。您可以使用@Override注释来执行此操作。

public class Trap implements GameObject {
    private String name;
    private Image icon;
    public GameObject(String name, Image icon) {
        this.name = name;
        this.icon = icon;
    } 

    @Override
    public String getName() {
        return name;
    }
    @Override
    public Image getIcon() {
        return icon;
    }
}

现在它实现了GameObject，我们可以将其添加到包含GameObject类型的列表

List<GameObject> special = new ArrayList<>();
myList.add(new Trap(myTrapName, myTrapImage));
myList.add(new Item(myItemName, myItemImage));

我们可以调用方法，而不必担心特定的GameObject是Item还是Trap

for (GameObject obj : special) {
    System.out.println(obj.getName());
}

Answer 4

您应该使用界面

public interface SpecialInterface{
   //you actually do not need any code, usually interfaces are called something+able 
   String getIcon();//this method will be filled in all the objects implementing this interface
}

现在，您在两个类中都实现了接口，例如：

public class Trap implements SpecialInterface{
   //...
}

现在您想要迭代您的项目和陷阱，您可以执行以下操作：

System.out.println(special[x][y].getIcon());

或..

if(special[x][y] instanceof Trap){
   Trap oneTrap = (Trap) special[x][y]; //here you transform your    SpecialInterface object in a Trap object
   System.out.println(special[x][y].icon);
}else{
   Item oneItem = (Item) special[x][y];
   System.out.println(special[x][y].icon);
}

注意：您的Trap和Item对象应声明为：

SpecialInterface trap = new Trap();

或

SpecialInterface item = new Item();

否则，您无法在矩阵中插入此对象。

Answer 5

一个特殊的数组应该是什么？我应该使用界面吗？如果是这样，怎么样？

如果你想要一个可以容纳两种不同类型元素的数组，那么它的元素类型必须是两者的超类型。这可能是两种类型实现的接口，也可能是两者的超类。

我建议您通过访问者方法访问成员（例如getIcon()）。如果您坚持直接访问它们（如示例中所示），则无法使用接口选项，并且您要访问的成员必须属于超类（或其超类之一）。

例如，

public interface GameObject {
    String getName();
    Icon getIcon();
}

public class Trap implements GameObject {

    private final String name;
    private final Icon icon;

    public Trap(String name, Icon icon) {
        this.name = name;
        this.icon = icon;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Icon getIcon() {
        return icon;
    }
}

（......和Item的相似...）

    GameObject[][] special = /* ... */;

    // ...

    if (special[x][y] == null) {
        return 0;
    }
    System.out.print(special[x][y].getName());
    return 1;

Answer 6

public class Entity {
    String name;
    Icon icon;
}

public class Item extends Entity {
    ...
    ...
}

public class Trap extends Entity {
    ...
    ...
}


Entity[][] special = new Entity[5][10];

现在您可以在special 2D数组中插入两个类中的任何一个，并且可以使用您在问题中提供的完全相同的代码。

if (special[x][y] == null)
    return 0;
System.out.print(special[x][y].icon);    /* here's where the issue is */
return 1;

一个包含不同Object类的数组

6 个答案: