A simple indicator of when a template would improve your code, is when you see that your code is frequently requiring you to cast an object to a different type. An example I found in my own Java code, which triggered me to convert an existing method signature to a template:
public MsgBase getLastSentMessage(Class<? extends MsgBase> msgBaseClass)
My client code always looked like this:
OrderResponse response = (OrderResponse) getLastSentMessage(OrderResponse.class);
and whenever I used that method, I had to cast the result to the correct subclass of the MsgBase type. The improved method signature was:
public <T extends MsgBase> T getLastSentMessage(Class<T> clazz)
Now the client code was:
OrderResponse response = getLastSentMessage(OrderResponse.class);
So to summarize, if you find yourself doing a lot of casting which seems unnecessary, you may have a good case where a template will clean up your code.
Update: a better way to generalize the above statement:
When your source class will be used by objects of many different types, and the source class can interact with those types at a higher (more abstract) level, but your client classes want to interact with specific subtypes, that is a case for using templates. (Container/List classes being the well-known example).