How to get an exception when casting a generic collection?

Question

Hi,
I have a bit of code that looks more or less like this:import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest {
     public static void main (String[] args) {
          try {
               get (Float.class);
          } catch (ClassCastException e) {
               System.err.println ("Oops");
               e.printStackTrace (System.err);
          try {
               Collection<Short> shorts = get (Short.class);
               for (Short s : shorts) {
                    System.out.println (s);
          } catch (ClassCastException e) {
               System.err.println ("Oops");
               e.printStackTrace (System.err);
          try {
               Collection<Number> numbers = get (Number.class);
               for (Number number : numbers) {
                    System.out.println (number);
          } catch (ClassCastException e) {
               System.out.println ("Oops again");
               e.printStackTrace (System.err);
     public static <T> Collection<T> get (Class<T> clazz) {
          Collection<T> ret = new ArrayList<T> ();
          if (clazz == String.class) {
               ret.add (clazz.cast ("Test"));
          } else if (clazz == Integer.class) {
               ret.add (clazz.cast (Integer.valueOf (1)));
          } else if (clazz == Double.class) {
               ret.add (clazz.cast (Double.valueOf (1.0)));
          } else if (clazz == Float.class) {
               ret.add (clazz.cast ("Bug")); // Bug here, blatent
          } else if (clazz == Short.class) {
               ret.add ((T) "Bug"); // Bug here, latent
          } else if (clazz == Number.class) {
               ret.addAll (get (Integer.class));
               ret.addAll (get (Double.class));
               ret.addAll (get (String.class)); // Another bug here, latent
          return ret;
}Obviously this doesn't compile as-is, I have to add 3 casts towards the end. Then when I add the casts and run the program I discover I have several bugs, some of which are fail-early and some of which lie hidden until the further away from the bug Since I have the type-token, I use it to check the simple cast, but is there any way I can get a failure more or less at the point where the dodgy Collection cast is made?

Answer 1

OK, sorry not to be clear. My example code is meant to crash on the erroneous casts - clearly a String cannot be cast to a Float, nor a Short. My point is that in one case the code crashes at the point where the cast is made and in another case the code crashes later on. What I want to achieve is this early failure in case of buggy code. Here is a shorter example:import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest {     
     public static <T> Collection<T> get (Class<T> clazz) {
          Collection<T> ret = new ArrayList<T> ();
          if (clazz == String.class) {
               ret.add (clazz.cast ("Test"));
          } else if (clazz == Integer.class) {
               ret.add (clazz.cast (Integer.valueOf (1)));
          } else if (clazz == Double.class) {
               ret.add (clazz.cast (Double.valueOf (1.0)));
          } else if (clazz == Number.class) {
               ret.addAll ((Collection<? extends T>) get (Integer.class));
               ret.addAll ((Collection<? extends T>) get (Double.class));
                // This is a bug, but how can I get an exception at this point?
               ret.addAll ((Collection<? extends T>) get (String.class));
          return ret;
}If I mistakenly write this code it will compile (with the addition of the appropriate casts). However, my code is buggy and will fail when the user of the collection receives a String when he is expecting a Number. My question is, how can I get my code to fail where I make the erroneous cast? If you look at the code I originally posted I have two casts of the String "Bug", one of which is done by (T) and the other is clazz.cast. The first example fails late and the second fails early - it is this early failure that I would like to achieve, in the case of buggy code, in my example above.
Am I making sense yet?