Why does setting class a to class b work?/How can I make my method universal?

So before I start this off I would like to give a little disclaimer. I do not really understand what is happening here so I apologize if my paragraph does not make much sense. I will try my best to convey my question, and, hopefully, y'all will be able to help me. So here goes.

I have been working on a basic test based adventure game/dungeon crawler. While creating an encounter method for when you find a monster, I realized that I needed a way to parse through my Hashtables full of my monster classes. Problem was, I had set the keys to Strings for easier access when wanting to add a specific item to the player's storage or to add a specific monster to a fight. So I decided to create a method which would receive a Hashtable I fed it and spit back out a random key, which I would then use to get the monster from my database. I attempted to create a method that would work for all Hashtables with a String, class format, and a sample of my attempted parsing code resides below.

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

This didn't work, as the program complained about the table (which I fed like so(Hashtable table)) was an object and therefore the program would have a seizure if it was forced to try to pull keys out of it. Now if someone can explain this, I would appreciate it, but it is not the core of my question. Eventually, I changed my path of attack to a try-catch system where I would have two Hasthables that shared the same types as the two database Hashtables in my program. Then the program would try to set the provided hashtable to one and if that failed stick it in another. The funny thing is, I fed my method my monster class, and it set it to a Hashtable that stores data as String, item. Now, since I only am getting the key from these I guess it doesn't really matter what happens to the class, but how is monster changed to item without any errors being thrown? I mean I guess they both take data in the following order (int, int, String, int) so I guess the creation could work, and I assume this is what happened. Am I correct in this? Is this a problem? Since I'm using just the key can I somehow make the method universal where it only takes the keys from table instead of the keys and values?

Here is my item class.

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;
		}
	}

Here is my monster class.

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;
		}
	}

And finally, here is my Method.

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";
	}

I believe the reason it works is that when item_data_base is set equal to table the original parameters of item_data_base are overwritten. So one last question, why does that work when just using the raw table value doesn't?

(Working code)

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";
	}

(Broken Code)

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";
	}