Java

Because Java employes type erasure, it is not possible, nor would it be useful, to create new, generic types at runtime. Take the following program:

  1. import java.lang.Class;
  2. import java.util.ArrayList;
  3. import java.lang.reflect.Constructor;
  5. class Main {
  6.     public static void printLen(ArrayList<?> list)  {
  7.         System.out.println(list.size());
  8.     }
  10.     public static void main(String[] args) throws Exception {
  11.         // We can get the Class based on a string value -- a useful feature for
  12.         // some meta programming.
  13.         Class<?> intClass = Class.forName("java.lang.Integer");
  15.         // Get the constructor for instantiating an ArrayList.
  16.         Constructor<ArrayList> listCtor = ArrayList.class.getDeclaredConstructor();
  18.         // But there is no way to instantiate ArrayList using the intClass!
  19.         // Instead all we can do is create the ArrayList the way it would look
  20.         // at runtime anyway.
  21.         ArrayList ints = listCtor.newInstance();
  23.         // Add some integers to the list.
  24.         ints.add(1);
  25.         ints.add(2);
  26.         ints.add(3);
  28.         // And because there is no type safety for lists created at runtime,
  29.         // and we used reflection to mimic that here, there's no compile-time
  30.         // type safety either!
  31.         ints.add("Hello");
  33.         // That said, we *can* assert some compile-time type safety back into
  34.         // the mix by randomly declaring "strs" to be an ArrayList<String>.
  35.         //
  36.         // But remember, we did *nothing* to ensure the underlying storage of
  37.         // strs is bound to the String class. Again, this is purely a compile-
  38.         // time conveience feature.
  39.         ArrayList<String> strs = listCtor.newInstance();
  40.         strs.add("Hello");
  41.         strs.add("world");
  43.         // By asserting that strs is "ArrayList<String>", the following line
  44.         // would cause a compile error as expected.
  45.         // strs.add(1);
  47.         printLen(ints);
  48.         printLen(strs);
  49.     }
  50. }

The code comments in the above program demonstrate that Java does not allow runtime instantiation from generic types. Which makes sense, as generics are strictly a compile-time convenience feature in Java.

To run the above program, please follow these instructions:

  1. Launch the container:

    1.  docker run -it --rm go-generics-the-hard-way

  2. Compile the above program:

    1.  javac -g ./05-internals/03-runtime-instantiation/java/main.java

  3. Run the program:

    1.  java -classpath ./05-internals/03-runtime-instantiation/java Main
    1.  4
    2.  2

  4. Type exit to stop and remove the container.

It bears saying once more — generics in Java are purely a compile-time, convenience feature. What about .NET and Go?

Next: .NET