code: public Reflect create(Object... args) throws ReflectException {
          Class<?>[] types = types(args);
  
          // Try invoking the "canonical" constructor, i.e. the one with exact
          // matching argument types
          try {
              Constructor<?> constructor = type().getDeclaredConstructor(types);
              return on(constructor, args);
          }
  
          // If there is no exact match, try to find one that has a "similar"
          // signature if primitive argument types are converted to their wrappers
          catch (NoSuchMethodException e) {
              for (Constructor<?> constructor : type().getConstructors()) {
                  if (match(constructor.getParameterTypes(), types)) {
                      return on(constructor, args);
                  }
              }
  
              throw new ReflectException(e);
          }
      }
docs: Call a constructor.
  <p>
  This is roughly equivalent to {@link Constructor#newInstance(Object...)}. If the wrapped object is a
  {@link Class}, then this will create a new object of that class. If the wrapped object is any other
  {@link Object}, then this will create a new object of the same type.
  <p>
  Just like {@link Constructor#newInstance(Object...)}, this will try to wrap primitive types or unwrap primitive
  type wrappers if applicable. If several constructors are applicable, by that rule, the first one encountered is
  called. i.e. when calling <code><pre>
  on(C.class).create(1, 1);
  </pre></code> The first of the following constructors will be applied: <code><pre>
  public C(int param1, Integer param2);
  public C(Integer param1, int param2);
  public C(Number param1, Number param2);
  public C(Number param1, Object param2);
  public C(int param1, Object param2);
  </pre></code>
  
  @param args
  The constructor arguments
  @return The wrapped new object, to be used for further reflection.
  @throws ReflectException
  If any reflection exception occurred.