Java 为什么将a类设置为b类有效？/我如何使我的方法通用？

所以在我开始之前，我想给出一点免责声明。我真的不明白这里发生了什么，所以如果我的段落没有多大意义，我道歉。我会尽力表达我的问题，希望你们能帮助我。这就来了

我一直在做一个基本的基于测试的冒险游戏/地下城爬虫。在为查找怪物创建遭遇方法时，我意识到我需要一种方法来解析包含怪物类的哈希表。问题是，当我想在玩家的存储中添加一个特定的物品或者在战斗中添加一个特定的怪物时，我已经将键设置为字符串以便于访问。因此，我决定创建一个方法，该方法将接收一个哈希表，我将其输入，并吐出一个随机键，然后使用该键从我的数据库中获取怪物。我试图创建一个方法，该方法适用于所有具有字符串、类格式的哈希表，下面是我尝试的解析代码示例

for(String key: table.getkeys())
{
    if(num_of_loops_to_do==times_looped)
    {
        return key;
    }
}

这不起作用，因为程序抱怨表（我像这样输入（Hashtable table））是一个对象，因此，如果程序被迫尝试从中拉出键，它将被卡住。如果有人能解释这一点，我会很感激，但这不是我问题的核心。最后，我将攻击路径改为try-catch系统，在该系统中，我将有两个hasthable，它们与程序中的两个数据库哈希表共享相同的类型。然后程序将尝试将提供的哈希表设置为一个，如果设置失败，则将其粘贴到另一个哈希表中。有趣的是，我将我的方法输入了monster类，然后它将其设置为一个哈希表，该哈希表将数据存储为String，item。现在，因为我只从这些中获得了密钥，我想这与类发生了什么并不重要，但是monster如何在不抛出任何错误的情况下更改为item呢？我的意思是，我猜他们都是按以下顺序（int，int，String，int）获取数据的，所以我猜创建可以工作，我假设这就是发生的情况。我说的对吗？这是个问题吗？既然我只使用了键，我能不能让这个方法变得通用，它只从表中获取键，而不是键和值

这是我的项目类

static class item
    {
        private int durability;
        private int damage;
        private String name;
        private int rarity_level;
        item(int durability, int damage, String name, int rarity_level)
        {
            this.durability=durability;
            this.damage=damage;
            this.name=name;
            this.rarity_level=rarity_level;
        }
        String get_name() 
        {
            return name;
        }
        int get_durability() 
        {
            return durability;
        }
        int get_damage() 
        {
            return damage;
        }
        void change_durability(int change_in_durabilty) 
        {
            durability=durability+change_in_durabilty;
        }
        int get_rarity_level() 
        {
            return rarity_level;
        }
    }

这是我的怪物课

static class monster
    {
        private int health;
        private int damage;
        private String name;
        private int level;
        monster(int health, int damage, String name, int level)
        {
            this.health=health;
            this.damage=damage;
            this.name=name;
            this.level=level;
        }
        String get_name() 
        {
            return name;
        }
        int get_health() 
        {
            return health;
        }
        int get_damage() 
        {
            return damage;
        }
        void change_health(int change_in_durabilty) 
        {
            health=health+change_in_durabilty;
        }
        int get_level() 
        {
            return level;
        }
    }

最后，这里是我的方法

public static String get_Ran_Object_From_Dict(Hashtable table) 
    {
        Random rand=new Random();
        int object_num_to_retrieve=rand.nextInt(table.size());
        Hashtable<String, Data.item> item_data_base=new Hashtable<String, Data.item>();
        Hashtable<String, Data.monster> monster_data_base=new Hashtable<String, Data.monster>();
        try {
            item_data_base=table;
        }
        catch(Exception e)
        {
            monster_data_base=table;
        }
        int num_looped=0;
        System.out.println(item_data_base.size());
        System.out.println(monster_data_base.size());
        if(monster_data_base.size()>0) {
            System.out.println("monster");
            for(String key : monster_data_base.keySet()) 
            {
                if(num_looped==object_num_to_retrieve) 
                {
                    return key;
                }
                num_looped+=1;
            }
        }
        else 
        {
            System.out.println("item");
            for(String key : item_data_base.keySet()) 
            {
                if(num_looped==object_num_to_retrieve) 
                {
                    return key;
                }
                num_looped+=1;
            }
        }
        return "System_fail";
    }

public静态字符串get\u run\u Object\u From\u Dict（哈希表）
{
Random rand=新的Random（）；
int object_num_to_retrieve=rand.nextInt（table.size（））；
Hashtable item_data_base=新的Hashtable（）；
Hashtable monster_data_base=新Hashtable（）；
试一试{
项目\数据\基础=表格；
}
捕获（例外e）
{
monster_data_base=表格；
}
int num_循环=0；
System.out.println（item_data_base.size（））；
System.out.println（monster_data_base.size（））；
if（monster_data_base.size（）>0）{
System.out.println（“怪物”）；
for（字符串键：monster\u data\u base.keySet（））
{
if（num_looped==要检索的对象数量）
{
返回键；
}
循环次数+=1；
}
}
其他的
{
系统输出打印项次（“项目”）；
for（字符串键：item\u data\u base.keySet（））
{
if（num_looped==要检索的对象数量）
{
返回键；
}
循环次数+=1；
}
}
返回“系统故障”；
}

我相信它工作的原因是，当item_data_base设置为等于table时，item_data_base的原始参数会被覆盖。最后一个问题是，为什么仅仅使用原始表值不起作用

（工作守则）

---

这个问题太长太冗长了。你能不能把这个问题提炼成一个更容易理解的问题？

Hashtable

是一种原始类型。如果丢失了所有类型信息，那么调用什么方法并不重要。当您取出对象时，您正在为自己设置一个类强制转换异常。这个try/catch的想法从根本上被打破了。我可以告诉你，问题顶部的第一段代码毫无意义。它总是返回

表中的第一个键，或者根本不返回，这取决于
num\u of_loops\u to\u do==times\u looped
是否为
true
进入。由于值
num\u of_loops\u to_do==times\u looped
在循环内从未更改，因此循环是无用的。这两个变量是预先定义的。我试图通过制造变量来表达我的意思。我在循环中遇到的问题是，我会得到一个错误，说类型不匹配，无法从对象类型转换为字符串。我故意输入一个未定义的原始哈希表，以便该方法可以用于任何和所有哈希表。
public static String get_Ran_Object_From_Dict(Hashtable table) 
    {
        //By creating dictionary with defined parameters I can then set it to table and it wont explode.
        Random rand=new Random();
        int object_num_to_retrieve=rand.nextInt(table.size());
        Hashtable<String, String> hashtable=new Hashtable<String, String>();
        hashtable=table;
        int num_looped=0;
        for(String key :hashtable.keySet()) 
        {
            if(num_looped==object_num_to_retrieve) 
            {
                return key;
            }
            num_looped+=1;
        }
        return "System_fail";
    }

public static String get_Ran_Object_From_Dict(Hashtable table) 
    {
        Random rand=new Random();
        int object_num_to_retrieve=rand.nextInt(table.size());
        int num_looped=0;
        for(String key :table.keySet()) 
        {
            if(num_looped==object_num_to_retrieve) 
            {
                return key;
            }
            num_looped+=1;
        }
        return "System_fail";
    }