How to use

getName

method

in

java.lang.Class

  @Override
  public String toString() {
    return (String.class.getName() + " -> @" + this.annotationType.getName() + " " +
        this.fieldType.getName() + ": " + this.annotationFormatterFactory);
  }
}

 private boolean isMyServiceRunning(Class<?> serviceClass) {
  ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
  for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
    if (serviceClass.getName().equals(service.service.getClassName())) {
      return true;
    }
  }
  return false;
}

/**
 * Returns human readable string representation of {@code type}.
 *
 * <p>The format is subject to change.
 */
static String toString(Type type) {
 return (type instanceof Class) ? ((Class<?>) type).getName() : type.toString();
}

 @Override public String toString() {
  return String.format("%s.%s() %s",
    method.getDeclaringClass().getName(), method.getName(), arguments);
 }
}

  @Override
  public String toString() {
    return clazz.getName() + " " + name;
  }
}

  @Override
  public String toString() {
    return clazz.getName() + " " + name;
  }
}

/**
 * Returns the package name of {@code clazz} according to the Java Language Specification (section
 * 6.7). Unlike {@link Class#getPackage}, this method only parses the class name, without
 * attempting to define the {@link Package} and hence load files.
 */
public static String getPackageName(Class<?> clazz) {
 return getPackageName(clazz.getName());
}

@SuppressWarnings("unchecked")
static Class<? extends Annotation> getAnnotationType(AnnotationFormatterFactory<? extends Annotation> factory) {
  Class<? extends Annotation> annotationType = (Class<? extends Annotation>)
      GenericTypeResolver.resolveTypeArgument(factory.getClass(), AnnotationFormatterFactory.class);
  if (annotationType == null) {
    throw new IllegalArgumentException("Unable to extract parameterized Annotation type argument from " +
        "AnnotationFormatterFactory [" + factory.getClass().getName() +
        "]; does the factory parameterize the <A extends Annotation> generic type?");
  }
  return annotationType;
}

@Override
public void destroy() {
  if (this.loadTimeWeaver instanceof InstrumentationLoadTimeWeaver) {
    if (logger.isDebugEnabled()) {
      logger.debug("Removing all registered transformers for class loader: " +
          this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName());
    }
    ((InstrumentationLoadTimeWeaver) this.loadTimeWeaver).removeTransformers();
  }
}

 @Override
 public boolean apply(StackTraceElement element) {
  return element.getClassName().equals(clazz.getName());
 }
};

  /**
   * Report a ProtocolViolationException with a personalized message referencing
   * the simple type name of the consumer class and report it via
   * RxJavaPlugins.onError.
   * @param consumer the class of the consumer
   */
  public static void reportDoubleSubscription(Class<?> consumer) {
    RxJavaPlugins.onError(new ProtocolViolationException(composeMessage(consumer.getName())));
  }
}

private void runTestMethod(ClassLoader classLoader) throws Exception {
 Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
 Object testInstance = test.newInstance();
 test.getMethod("setUp").invoke(testInstance);
 test.getMethod(getName()).invoke(testInstance);
 test.getMethod("tearDown").invoke(testInstance);
}

private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
  throws Exception {
 // Make sure we are actually running with the expected helper implementation
 Class<?> abstractFutureClass = classLoader.loadClass(AbstractFuture.class.getName());
 Field helperField = abstractFutureClass.getDeclaredField("ATOMIC_HELPER");
 helperField.setAccessible(true);
 assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName());
}

private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
  throws Exception {
 // Make sure we are actually running with the expected helper implementation
 Class<?> abstractFutureClass = classLoader.loadClass(AggregateFutureState.class.getName());
 Field helperField = abstractFutureClass.getDeclaredField("ATOMIC_HELPER");
 helperField.setAccessible(true);
 assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName());
}

private static ResourceInfo resourceInfo(Class<?> cls) {
 String resource = cls.getName().replace('.', '/') + ".class";
 ClassLoader loader = cls.getClassLoader();
 return ResourceInfo.of(resource, loader);
}

private static ClassPath.ClassInfo findClass(
  Iterable<ClassPath.ClassInfo> classes, Class<?> cls) {
 for (ClassPath.ClassInfo classInfo : classes) {
  if (classInfo.getName().equals(cls.getName())) {
   return classInfo;
  }
 }
 throw new AssertionError("failed to find " + cls);
}

private void checkStackTrace(ExecutionException e) {
 // Our call site for get() should be in the trace.
 int index = findStackFrame(e, getClass().getName(), "getExpectingExecutionException");
 assertThat(index).isNotEqualTo(0);
 // Above our method should be the call to get(). Don't assert on the class
 // because it could be some superclass.
 assertThat(e.getStackTrace()[index - 1].getMethodName()).isEqualTo("get");
}

public void testToString() {
 assertEquals(int[].class.getName(), Types.toString(int[].class));
 assertEquals(int[][].class.getName(), Types.toString(int[][].class));
 assertEquals(String[].class.getName(), Types.toString(String[].class));
 Type elementType = List.class.getTypeParameters()[0];
 assertEquals(elementType.toString(), Types.toString(elementType));
}

public <T> void testToString() {
 assertEquals(String.class.getName(), new TypeToken<String>() {}.toString());
 assertEquals("T", TypeToken.of(new TypeCapture<T>() {}.capture()).toString());
 assertEquals("java.lang.String", new Entry<String, Integer>() {}.keyType().toString());
}

public void testGetPackageName() throws Exception {
 assertEquals("java.lang", Reflection.getPackageName(Iterable.class));
 assertEquals("java", Reflection.getPackageName("java.MyType"));
 assertEquals("java.lang", Reflection.getPackageName(Iterable.class.getName()));
 assertEquals("", Reflection.getPackageName("NoPackage"));
 assertEquals("java.util", Reflection.getPackageName(Map.Entry.class));
}