Here is my code: http://pastebin.com/wKSu5UD1

It would be more helpful for future readers if you just posted the code instead of a link to the code.

I cant seem to figure out how to insert items from "Item array" into "Backpack array" just by using reference ID which is also happens to be array index.

It seems to be a project problem. An "Item" class should be used to implement a general item, not more than one. If you wanted a different class for swords, you could create another class called "Weapon", which inherits "Item", and another one called "Sword". Then, you could create a class to store ANY type of Item, no matter if they are a sword or a jewel or a coin. I'll give you a little example without being too complex about this.

First of all, I've implemented a class called Item:

public class Item extends Object {

	int ID;
	String name;
	int price;
	
	public Item(int itemID, String itemName, int itemPrice) {
		ID = itemID;
		name = itemName;
		price = itemPrice;
	}
	
	public void changeID(int newID) {
		ID = newID;
	}
	
	public void changeName(String newName) {
		name = newName;
	}
	
	public void chagePrice(int newPrice) {
		price = newPrice;
	}
	
	public int getID() {
		return ID;
	}
	
	public String getName() {
		return name;
	}
	
	public int getPrice() {
		return price;
	}
	
}

It has 3 attributes. Their values are defined at the moment you create an Item object. All the 3 attributes have their own access and modifier methods.

Then, you implement a class called "ItemCollection" to store any kind of item, and extend ArrayList. Use the generics for "Item", so that it can be used only for items.

package example;

import java.util.ArrayList;
public class ItemCollection<Item> extends ArrayList<Item> {

	private static final long serialVersionUID = 1L;
	
}

Then, in your main class and method, you create an instance of the ItemCollection, and an instance for every Item, and then add each Item to the ItemCollection:

package example;

public class Main {

	public static ItemCollection<Item> itemCollection;
	
	public static void main(String[] args) {
		
		itemCollection = new ItemCollection<Item>();
		int defaultValue = 50;
		Item boot = new Item(0, "Boot", defaultValue);
		Item sword = new Item(1, "Sword", defaultValue);
		Item ring = new Item(2, "Ring", defaultValue);
		Item dagger = new Item(3, "Dagger", defaultValue);
		Item bow = new Item(4, "Bow", defaultValue);
		
		itemCollection.add(boot); itemCollection.add(sword);
		itemCollection.add(ring); itemCollection.add(dagger);
		itemCollection.add(bow);
	}

}

Then you create another class just like ArrayCollection, for the Backpack, and add to it a method to "addItemByID", passing the ID as an argument.

package example;

import java.util.ArrayList;
public class Backpack<Item> extends ArrayList<Item> {

	private static final long serialVersionUID = 1L;

	public void addItemByID(int itemID) {
		for (example.Item i : Main.itemCollection) {
			if (i!=null) {
				if (i.ID == itemID) {
					add((Item) i);
				}
			}
		}
	}
	
}

And then, in the main method, you just add to the backpack by the ID:

Backpack<Item> backPack = new Backpack<Item>();
		backPack.addItemByID(3); // Add a Dagger.
		System.out.println(backPack.get(0).name); // Print the Dagger Item name.

By the way, try to avoid using "arrays" in Java. They're primitive data types. Try to use ArrayLists instead (They have all these fancy methods that are just beautiful :) ). It's nothing like a list in Python, but much better than an "array".

Although this isn't wrong in principle and actually correct to a degree, it should be mentioned that OOP has a second mechanism besides inheritance, and that is composition. I urge the OP to notice this because inheritance, since being kind of innovation in OOP, is somewhat forced by textbooks and internet sources, so it seems to be the magic weapon. This is not true. Relying only on inheritance does not solve problems but leads to unmaintainable code. This becomes clear only after a while, namely if the codebase begins to grow noticeable. Either you end up in spaghetti inheritance or the so-called "God class".

To explain it a bit further, I exaggerate a bit:

Item <= RightHandUseable <= Weapon <= Cutter <= Sword <= MagicSword <= SwordOfKalmahar <= EnhancedSwordOfKalmahar

Or should it better be

Item <= Weapon <= Cutter <= RightHandUseable <= ...

This can be defused a bit when using mix-in inheritance, i.e. inheriting orthogonal functionality, but that is possible only by inheriting interfaces (in Java) so have to implement them each and every time. Now, what is with a Stick? It is inherited from Tool or, specialized, Lever because it is a tool to activate a mechanism when inserted into a slot, or is it a Weapon because it can be used as a Cudgel?

Doing all this is right is probably too much when still learning the language; but don't get trapped by the ideas coming from a single source. Be open.

First of all, I would like to say that If I was going to develop a "MMORPG" or anything that would require such level of inheritance, I would probably use Python or C++ (And not Java. Java would be the last option.. If I really needed to develop a game like in Android, for example). In Python I would be able to inherit from more than on class, and all this could have a much better project approach. When you mentioned "RightHandUseable", the first thing that came to my mind was interfaces, but, just like you've said, it is too much to consider when learning a language (That's why I did not mention interfaces).

It's necessary to point out that he could do that in C or "procedural Python" and organize his code in a non-OP-way. I started like that at the beginning, because Object Oriented Programming could not enter in my head (It took a lot of time).

Item <= Weapon <= Sword <= SpecificSword1 implements RightHandUseable implements LeftHandUseable <= SpecificSword2 implements RightHandUseable implements LeftHandUseable.

That's probably the approach that I would follow in Java.

Edit: By the way, the biggest problem that I found in his code, was the primitive array. Even if he makes of an "Item" class thousand things and ignores OOP, he could do it to learn more and more.. But.. The array is the problem! haha. He could do anything with an ArrayList, and things like "append to another ArrayList by ID" gets much more easier, and he could do it without being too object-oriented by that.. But, as I've said, he could use C. If he's using Java, it's better to study more and more about object-oriented programming.

I've implemented an example with a more non-object-oriented approach, using a class inside another class (Same file). I've implemented using HashMaps. The only difference is that each category as an ID, not each item (And that's good, considering that your game is much smaller than Tibia, for example).

package example;

import java.util.ArrayList;
import java.util.HashMap;

public class Main {

	// HashMap with arrayLists of items by ID.
	public static HashMap<Integer, ArrayList<String>> items = new HashMap<Integer, ArrayList<String>>();
	// Backpack with a slightly different structure.
	public static HashMap<Integer, String> backpack = new HashMap<Integer, String>();
	
	public static void main(String[] args) {

		// Creating the arrayLists.
		ArrayList<String> boots = new ArrayList<String>();
		ArrayList<String> swords = new ArrayList<String>();
		ArrayList<String> rings = new ArrayList<String>();
		ArrayList<String> daggers = new ArrayList<String>();
		ArrayList<String> bows = new ArrayList<String>();
		
		// Adding content to them...
		for (Integer i = 0; i < 10; i++) {
			boots.add("Boot" + i.toString());
			swords.add("Sword" + i.toString());
			rings.add("Ring" + i.toString());
			daggers.add("Dagger" + i.toString());
			bows.add("Bow" + i.toString());
		}
		
		// Putting the arrayLists to the HashMap of items by their IDs.
		items.put(ID.BOOTS, boots); items.put(ID.SWORDS, swords);
		items.put(ID.RINGS, rings); items.put(ID.DAGGERS, daggers);
		items.put(ID.BOWS, bows);
		
		// Printing all the content in all arrayLists in all IDs.
		for (ArrayList<String> e : items.values()) {
			for (int i = 0; i < e.size(); i++) {
				if (e.get(i)!=null) {
					System.out.println(e.get(i));
				}
			}
		}
		
		// Here you could add any item to the backpack.
		// backpack.put(ID.SWORDS, swords.get(0));
	}

	public class ID {
		
		//Defining constant-IDs.
		public static final int BOOTS = 0;
		public static final int SWORDS = 1;
		public static final int RINGS = 2;
		public static final int DAGGERS = 3;
		public static final int BOWS = 4;
		
	}
	
}