How to use

getConstructor

method

in

java.lang.Class

public SqlDateDeserializer(Class cl)
    throws NoSuchMethodException {
  _cl = cl;
  _constructor = cl.getConstructor(new Class[]{long.class});
}

private boolean isWrapperClass(Class<?> clazz) {
  try {
    clazz.getConstructor(type);
    return true;
  } catch (NoSuchMethodException e) {
    return false;
  }
}

public StringValueDeserializer(Class cl) {
  try {
    _cl = cl;
    _constructor = cl.getConstructor(new Class[]{String.class});
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}

public CertificateChainCleaner buildCertificateChainCleaner(X509TrustManager trustManager) {
 try {
  Class<?> extensionsClass = Class.forName("android.net.http.X509TrustManagerExtensions");
  Constructor<?> constructor = extensionsClass.getConstructor(X509TrustManager.class);
  Object extensions = constructor.newInstance(trustManager);
  Method checkServerTrusted = extensionsClass.getMethod(
    "checkServerTrusted", X509Certificate[].class, String.class, String.class);
  return new AndroidCertificateChainCleaner(extensions, checkServerTrusted);
 } catch (Exception e) {
  throw new AssertionError(e);
 }
}

 private static @Nullable Constructor<Thread> getBigThreadConstructor() {
  try {
   return Thread.class.getConstructor(
     ThreadGroup.class, Runnable.class, String.class, long.class, boolean.class);
  } catch (Throwable t) {
   // Probably pre Java 9. We'll fall back to Thread.inheritableThreadLocals.
   return null;
  }
 }
}

public static Constructor findConstructor(String desc, ClassLoader loader) {
  try {
    int lparen = desc.indexOf('(');
    String className = desc.substring(0, lparen).trim();
    return getClass(className, loader).getConstructor(parseTypes(desc, loader));
  }
  catch (ClassNotFoundException | NoSuchMethodException ex) {
    throw new CodeGenerationException(ex);
  }
}

public void testConstructor_notDeclaredByType() throws NoSuchMethodException {
 Constructor<String> constructor = String.class.getConstructor();
 try {
  TypeToken.of(Object.class).constructor(constructor);
  fail();
 } catch (IllegalArgumentException expected) {
 }
}

public void testConstructor_declaredBySuperclass() throws NoSuchMethodException {
 Constructor<Object> constructor = Object.class.getConstructor();
 try {
  TypeToken.of(String.class).constructor(constructor);
  fail();
 } catch (IllegalArgumentException expected) {
 }
}

public <T extends CannotConstruct<AssertionError>> void testConstructor_exceptionTypes()
  throws NoSuchMethodException {
 @SuppressWarnings("rawtypes") // Reflection API skew
 Constructor<CannotConstruct> constructor = CannotConstruct.class.getConstructor();
 Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.constructor(constructor);
 assertThat(invokable.getExceptionTypes()).contains(TypeToken.of(AssertionError.class));
}

public <T extends Container<String>> void testConstructor_parameterTypes()
  throws NoSuchMethodException {
 @SuppressWarnings("rawtypes") // Reflection API skew
 Constructor<Container> constructor = Container.class.getConstructor(Object.class);
 Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.constructor(constructor);
 ImmutableList<Parameter> params = invokable.getParameters();
 assertEquals(1, params.size());
 assertEquals(TypeToken.of(String.class), params.get(0).getType());
}

@Test
public void forConstructorParameter() throws Exception {
  Constructor<Constructors> constructor = Constructors.class.getConstructor(List.class);
  ResolvableType type = ResolvableType.forConstructorParameter(constructor, 0);
  assertThat(type.getType(), equalTo(constructor.getGenericParameterTypes()[0]));
}

@Test
public void javaLangAnnotationTypeViaFindMergedAnnotation() throws Exception {
  Constructor<?> deprecatedCtor = Date.class.getConstructor(String.class);
  assertEquals(deprecatedCtor.getAnnotation(Deprecated.class), findMergedAnnotation(deprecatedCtor, Deprecated.class));
  assertEquals(Date.class.getAnnotation(Deprecated.class), findMergedAnnotation(Date.class, Deprecated.class));
}

public void testConstructor_getOwnerType() throws NoSuchMethodException {
 @SuppressWarnings("rawtypes") // raw class ArrayList.class
 Constructor<ArrayList> constructor = ArrayList.class.getConstructor();
 assertEquals(
   TypeToken.of(ArrayList.class),
   TypeToken.of(ArrayList.class).constructor(constructor).getOwnerType());
 assertEquals(
   new TypeToken<ArrayList<String>>() {},
   new TypeToken<ArrayList<String>>() {}.constructor(constructor).getOwnerType());
}

@Test
public void resolveTypeVariableFromConstructorParameter() throws Exception {
  Constructor<?> constructor = Constructors.class.getConstructor(List.class);
  ResolvableType type = ResolvableType.forConstructorParameter(constructor, 0);
  assertThat(type.resolve(), equalTo((Class) List.class));
  assertThat(type.resolveGeneric(0), equalTo((Class) CharSequence.class));
}

@Test
public void resolveTypeVariableFromConstructorParameterWithImplementsClass() throws Exception {
  Constructor<?> constructor = Constructors.class.getConstructor(Map.class);
  ResolvableType type = ResolvableType.forConstructorParameter(
      constructor, 0, TypedConstructors.class);
  assertThat(type.resolve(), equalTo((Class) Map.class));
  assertThat(type.resolveGeneric(0), equalTo((Class) String.class));
}

@Test
public void resolveUnknownTypeVariableFromConstructorParameter() throws Exception {
  Constructor<?> constructor = Constructors.class.getConstructor(Map.class);
  ResolvableType type = ResolvableType.forConstructorParameter(constructor, 0);
  assertThat(type.resolve(), equalTo((Class) Map.class));
  assertThat(type.resolveGeneric(0), nullValue());
}

@Test
public void consParameterNameDiscoveryNoArgs() throws NoSuchMethodException {
  Constructor<TestObject> noArgsCons = TestObject.class.getConstructor();
  String[] names = discoverer.getParameterNames(noArgsCons);
  assertNotNull("should find cons info", names);
  assertEquals("no argument names", 0, names.length);
}

@Test
public void consParameterNameDiscoveryArgs() throws NoSuchMethodException {
  Constructor<TestObject> twoArgCons = TestObject.class.getConstructor(String.class, int.class);
  String[] names = discoverer.getParameterNames(twoArgCons);
  assertNotNull("should find cons info", names);
  assertEquals("one argument", 2, names.length);
  assertEquals("name", names[0]);
  assertEquals("age", names[1]);
}

@Test
public void serialize() throws Exception {
  testSerialization(ResolvableType.forClass(List.class));
  testSerialization(ResolvableType.forField(Fields.class.getField("charSequenceList")));
  testSerialization(ResolvableType.forMethodParameter(Methods.class.getMethod("charSequenceParameter", List.class), 0));
  testSerialization(ResolvableType.forMethodReturnType(Methods.class.getMethod("charSequenceReturn")));
  testSerialization(ResolvableType.forConstructorParameter(Constructors.class.getConstructor(List.class), 0));
  testSerialization(ResolvableType.forField(Fields.class.getField("charSequenceList")).getGeneric());
  ResolvableType deserializedNone = testSerialization(ResolvableType.NONE);
  assertThat(deserializedNone, sameInstance(ResolvableType.NONE));
}

public void testConstructor_equals() throws NoSuchMethodException {
 Constructor<?> defaultConstructor = ArrayList.class.getConstructor();
 Constructor<?> oneArgConstructor = ArrayList.class.getConstructor(int.class);
 new EqualsTester()
   .addEqualityGroup(Invokable.from(defaultConstructor), Invokable.from(defaultConstructor))
   .addEqualityGroup(Invokable.from(oneArgConstructor))
   .addEqualityGroup(new TypeToken<ArrayList<Integer>>() {}.constructor(defaultConstructor))
   .addEqualityGroup(new TypeToken<ArrayList<String>>() {}.constructor(defaultConstructor))
   .addEqualityGroup(new TypeToken<ArrayList<Integer>>() {}.constructor(oneArgConstructor))
   .addEqualityGroup(new TypeToken<ArrayList<String>>() {}.constructor(oneArgConstructor))
   .testEquals();
}