Accessing the class from a static method which the class owns is a bit tricky. From a non-static method accessing the class is as simple as doing this.

// get stack trace
StackTraceElement[] stackTrace = new Throwable().getStackTrace();

// get the class name at the top level of the stack trace
StackTraceElement stackTraceTopLevelElem = stackTrace[0];
String thisClassName = stackTraceTopLevelElem.getClassName();

// get the class using the class loader
Class thisClass;
try {
  thisClass = Class.forName(thisClassName);
} catch (ClassNotFoundException exc) {
  // this should never happen
}

public static void main(String[] args) {
  Class clazz = new ClassGetter().getClazz();
}

// inner class is necessary since getClassContext is protected
private static class ClassGetter extends SecurityManager {

  protected ClassGetter() {
    // do nothing
  }

  protected Class getClazz() {
    Class [] classes = getClassContext();
    Class clazz = classes[1];
    return clazz;
  }
}

Beginning in JDK 1.4.2, allocation of new objects is no longer expensive according to this article, Java theory and practice: Urban performance legends, revisited. According to this article.

… allocation in modern JVMs is far faster than the best performing malloc implementations…

The malloc/free approach deals with blocks of memory one at a time, whereas the garbage collection approach tends to deal with memory management in large batches, yielding more opportunities for optimization (at the cost of some loss in predictability).

This “plausibility argument” — that it is easier to clean up a mess in one big batch than to pick up individual pieces of dust throughout the day — is borne out by the data.

So allocate away, never object pool, don’t do strange, non-intuitive things to avoid allocating objects on the heap. Life is good.

There is an excellent tutorial at The Java Tutorial called
Using the Timer and TimerTask Classes.

It explains how to use a timer to schedule tasks or to perform tasks repeatedly. With the Timer and TimerTask classes you don’t have to create your own threads, it’s all done for you. Thank you Joshua Bloch for writing these classes.

On a side note, Joshua Bloch is one of the premier Java engineers. Recently he left Sun for Google. Gosh, that must have hurt Sun.

JavaWorld has a great article on finding a class’s runtime origin called Back to your Class roots. Below is the highly useful getClassLocation method from the article.

/**
 * Given a Class object, attempts to find its .class location.
 * Use for testing/debugging only.
 * 
 * @return URL that points to the class definition; null if not found
 */
public static URL getClassLocation (final Class cls) {
  if (cls == null) throw new IllegalArgumentException ("null input");
  
  URL result = null;
  final String clsAsResource = cls.getName ().replace ('.', '/').concat (".class");
  
  final ProtectionDomain pd = cls.getProtectionDomain ();
  // java.lang.Class contract does not specify if 'pd' can ever be
  // null; it is not the case for Sun's implementations, but guard
  // against null just in case:
  if (pd != null) {
    final CodeSource cs = pd.getCodeSource ();
    // 'cs' can be null depending on the classloader behavior:
    if (cs != null) result = cs.getLocation ();
    
    if (result != null) {
      // Convert a code source location into a full class file location
      // for some common cases:
      if ("file".equals (result.getProtocol ())) {
        try {
          if (result.toExternalForm ().endsWith (".jar") ||
            result.toExternalForm ().endsWith (".zip")) 
            result = new URL ("jar:".concat (result.toExternalForm ())
              .concat("!/").concat (clsAsResource));
          else if (new File (result.getFile ()).isDirectory ())
            result = new URL (result, clsAsResource);
        }
        catch (MalformedURLException ignore) {}
      }
    }
  }
  
  if (result == null) {
    // Try to find 'cls' definition as a resource; this is not
    // documented to be legal, but Sun's implementations seem to allow
    // this:
    final ClassLoader clsLoader = cls.getClassLoader ();
    
    result = clsLoader != null ?
      clsLoader.getResource (clsAsResource) :
      ClassLoader.getSystemResource (clsAsResource);
  }
  
  return result;
}