Question

I haven’t used generics before and I am wondering when I should use them and what the advantages are. I think it might be appropriate for a collection that I made since java always uses generics for collections as well but if I call the methods I created the type is already set in the function so it would give an error anyway. When should I use a generic class? Could you give an example because I am not sure how to use it. At the moment my code is as follows:

public class NodeList {
  private static final int MAX_AMOUNT_OF_NODES = 12;
  private HashMap<String, Node> nodeList;

  public NodeList(){
    nodeList    = new HashMap<String, Node>(MAX_AMOUNT_OF_NODES);
  }

  public Node get(String id){
    return nodeList.get(id);
  }

  public boolean add(Node node){
    if(nodeList.size() <= MAX_AMOUNT_OF_NODES){
      nodeList.put(node.id, node);
      return true;
    }
    return false;
  }
}

Answer 1

You can look at the existing API for guidance. For example, all the Collections are generic. That is because all collections contain elements of a type.

From that, it makes sense that generic classes should be used when you would have to create the exact same code again and again for different types. If you have to do that, generics might offer you some benefit.

As far as an example, the docs are a good place to start.

From that link, the first code sample is

public class Box<T> {

    // T stands for "Type"
    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

Conceptually, there is a Box class that is going to contain something. What it contains does not matter, because the type is specific by the programmer. A Box instance can contain basically anything. When the programmer needs to create a box, he/she specifies the type.

Box<SomeClass> myBox = new Box<SomeClass>();

Think about it this way — if you wanted to create a general Box that could hold anything without generics, you would have to

1) have the field f be an Object, or
2) create a Box class for every type a box could contain.

With generics, you only need one class, and you can specify the exact type. Maybe if you are doing something and your approach involved either 1 or 2 above, it’s better to use generics.