Type-information of generic type for a Parametrized class

Sometimes you feel that your code is world-class and deserves to be shared. There is one such class I have written for a personal project and find it to be extremely useful. You can view it here. Its called `CaptureType`

This class obtains the type information of the generic type and can be accessed in a type-safe manner. Some simple examples:

   static void test1() {
        CaptureType<String> t1 = new CaptureType<String>() {};
        equals(t1.getRawType(), String.class);
    }

    static void test2() {
        CaptureType<List<String>> t1 = new CaptureType<List<String>>() {};
        equals(t1.getRawType(), List.class);
        equals(t1.getParamADT().getParameters().get(0).getRawType(), String.class);
    }

Little tougher:

    static class Test4 extends CaptureType<List<String>> {}

    static void test4() {
        Test4 test4 = new Test4();
        equals(test4.getParamADT().getRawType(), List.class);
    }

    static class PreTest6<S> extends CaptureType<S> {}

    static class Test6 extends PreTest6<Integer> {
    }

A really tough one:

    class X<T> extends CaptureType<T> {
    }

    class Y<A, B> extends X<B> {
    }

    class Z<Q> extends Y<Q, Map<Integer, List<List<List<Integer>>>>> {
    }

    void test7(){
        Z<String> z = new Z<>();
        TypeADT param = z.getParamADT();
        equals(param.getRawType(), Map.class);
        List<TypeADT> parameters = param.getParameters();
        equals(parameters.get(0).getRawType(), Integer.class);
        equals(parameters.get(1).getRawType(), List.class);
        equals(parameters.get(1).getParameters().get(0).getRawType(), List.class);
        equals(parameters.get(1).getParameters().get(0).getParameters().get(0).getRawType(), List.class);
        equals(parameters.get(1).getParameters().get(0).getParameters().get(0).getParameters().get(0).getRawType(), Integer.class);
    }

This class captures information using Reflection. Sadly, it only obtain whatever reflection can provide. It captures generic types using the super token.
So in cases like:

 class SomeClass<T> extends CaptureType<T>{}
 SomeClass<String> claz = new SomeClass<>();

It is impossible to obtain the type information as it is erased. `CaptureType` class will only work,
if the type is mentioned while declaring the Class (at any point in hierarchy). For example in:

     class A<Z> extends CaptureType<Z>{}
     class B<E,T> extends A<T>{}
     class C <X,Y,Z> extends B<X, String>
     }

It is possible to obtain the type {@code String}, because it is mentioned at class level and can be mapped by following hierarchy. So `Z` in {@code A} is {@code String}

Please comment down your feedback. Even better an improvement :). I give as good as I get!