无法引用对象属性

Question

关于堆栈溢出的第一个问题！我觉得这一定是Java初学者的一个常见问题。但我已经尝试了几个小时，一直没有找到解决办法。我认为可以通过这种方式访问对象属性。

起初，我认为武器[0]实际上是一个对象数组，所以当我创建对象数组inventory[]inventory时，我在构造函数中使用了一个对象数组。我立即解决了这个问题，但这个问题仍然存在。

它甚至更烦人，因为在调试模式下，我可以看到inventory[]inventory及其属性中的武器[0]。看着Eclipse嘲笑我。

package arraytest;

import java.util.Scanner;
import java.util.InputMismatchException;
import java.lang.NumberFormatException;

public class ArrayTest {
    
    static Scanner kb = new Scanner(System.in);
    
    static int i = 0;
    static int choice = 0;
    
    public static void main(String[] args) {
        
        Weapons[] weapon = new Weapons[3];
        weapon[0] = new Weapons(0,"Wooden Sword",1,2);
        weapon[1] = new Weapons(1,"Bronze Sword",2.5,7.5);
        weapon[2] = new Weapons(2,"Iron Sword",5,10);
        
        Armor[] armor = new Armor[3];
        armor[0] = new Armor(3,"Wooden Armor",2,5);
        armor[1] = new Armor(4,"Bronze Armor",3,10);
        armor[2] = new Armor(5,"Iron Armor",5,15);
        
        Enemy[] enemy = new Enemy[3];
        enemy[0] = new Enemy(0,"Skeleton",3,0,10);
        enemy[1] = new Enemy(1,"Goblin",2,1,5);
        enemy[2] = new Enemy(2,"Zombie",4,1,8);
        
        Inventory[] inventory = new Inventory[256];
        
        String chooseweapon = String.format(
                "Choose your weapon:\n"
                + "1. %s\n"
                + "2. %s\n"
                + "3. %s\n"
                ,
                weapon[0].name,
                weapon[1].name,
                weapon[2].name
                );
        System.out.print(chooseweapon);
        
        while (i==0) {
            i++; //1
            
            try {
                choice = Integer.parseInt(kb.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Error. Try again.");
                i--; //0
                continue;
            }
            if (choice < 1 || choice > 3) {
                System.out.println("Error. Try again.");
                i--; //0
            }
        }
        if (choice == 1) {
            inventory[0] = new Inventory(weapon[0]);
        }
        System.out.println(inventory[0].item); //this is the problem here. i can't put .item.name, error is "name cannot be resolved or is not a field"
    }
}



class Inventory {
    
    public Object item;
    Inventory(Object item) {
        this.item = item;
        
    }
}

class Armor {
    public int id;
    public String name;
    public double defnum;
    public double val;
    
    Armor(int id, String name, double defnum, double val) {
        this.id = id;
        this.name = name;
        this.defnum = defnum;
        this.val = val;
    }
}

class Weapons {
    public int id;
    public String name;
    public double attdmg;
    public double val;
    
    Weapons(int id, String name, double attdmg, double val) {
        this.id = id;
        this.name = name;
        this.attdmg = attdmg;
        this.val = val;
    }
}

class Enemy {
    public int id;
    public String name;
    public double attdmg;
    public double defnum;
    public double health;
    
    Enemy(int id, String name, double attdmg, double defnum, double health) {
        this.id = id;
        this.name = name;
        this.attdmg = attdmg;
        this.defnum = defnum;
        this.health = health;
    }
}

Answer 1

欢迎来到StackOverflow！这是一个措辞得体的问题！

这与运行时的类型和编译时的类型之间的差异有关。您将项声明为对象类型。

Java允许多态性，当您将清单中的项声明为类型object时，允许您为项分配任何“是”对象的内容（这意味着您可以为项分配一个字符串、一个整数、任何对象，因为它们都继承自object类）。

但是，当您稍后在程序中访问item时，Java不能保证编译时引用的item都有name属性！例如，integer是对象，但没有name属性！Java编译器只是说，“我只知道项是对象，我不会让您访问并非所有对象都有的属性！”

但是，当您运行程序时，项的运行时类型是武器，因此Eclipse能够向您显示它的属性。但是Java被设计为在编译时捕获尽可能多的错误，因此如果它不能在编译时保证name属性具有名称，则它将不允许您访问该属性。

这可能看起来很烦人或不必要的限制（您知道要放入目录中的所有内容都有一个名称！），所以这就是超类和接口的意义所在！这些特性允许您灵活地创建不同类型的对象，这些对象都共享相似的属性或方法，并且仍然允许Java预先捕捉所有这些潜在的问题。

要解决这个问题，可以创建一个InventoryItem超类，Armor和Armare都扩展该超类，该超类具有Name属性。然后可以将Item声明为InventoryItem类型。这样，Java就会知道，即使运行时类型可能是武器或盔甲，它也保证有一个名称。

我们可以引入一个新类，例如InventoryItem:

class Inventory {

    public InventoryItem item;
    public int id;

    Inventory(InventoryItem item, int id) {
        this.item = item;
        this.id = id;
    }
}

然后类inventory可以接受inventoryItem（我建议inventory可能包含项数组）

class Inventory {

    public InventoryItem item;

    Inventory(InventoryItem item) {
        this.item = item;
    }

class Armor extends InventoryItem {

    public double defnum;
    public double val;

    Armor(int id, String name, double defnum, double val) {
        super(name, id);
        this.defnum = defnum;
        this.val = val;
    }
}

System.out.println(inventory[0].item.name); //Java now knows that inventory[0] is type Inventory, its "item" property is type InventoryItem, and that is *guaranteed* to have a name and id!