Page History

import java.io.IOException;
import java.lang.reflect.Field;
import sun.misc.Unsafe;

public class UnsafeCode {
  public static void main( String[] args ) throws SecurityException, NoSuchFieldException,
  IllegalArgumentException, IllegalAccessException {
    Field f = Unsafe.class.getDeclaredField("theUnsafe""theUnsafe");
    field.setAccessible(true);
    Unsafe u =  (Unsafe) field.get(null);
    u.throwException(new IOException(""No need to declare this checked exception""));
  }
}

public class BadNewInstance {
  private static Throwable throwable;

  private BadNewInstance() throws Throwable {
    throw throwable;
  }

  public static synchronized void undeclaredThrow(Throwable throwable) {
    // These two should not be passed
    if (throwable instanceof IllegalAccessException || throwable instanceof InstantiationException) {
        throw new IllegalArgumentException(); // Unchecked, no declaration required
    }
       
    BadNewInstance.throwable = throwable;
    try {
      BadNewInstance.class.newInstance();
    } catch (InstantiationException e) { /* dead code */ } 
      catch (IllegalAccessException e) { /* dead code */ } 
      finally { BadNewInstance.throwable = null; }  // Avoid memory leak
  }
}

public class UndeclaredException {
  public static void main(String[] args) {   // No declared checked exceptions
    BadNewInstance.undeclaredThrow(new Exception(""Any checked exception""));
  }
}

public static void main(String[] args) {
  try {	
    BadNewInstance.undeclaredThrow(new IOException(""Any checked exception""));
  } catch(Exception e) { 
    if (e instanceof IOException) {
      System.out.println(""IOException occurred"");
    } else if (e instanceof RuntimeException) {
      throw (RuntimeException) e;
    } else {
      //some other unknown checked exception
    }
  } 
} 

// Generic type for a builder used to build any object of type T
public interface Builder<T>Builder&lt;T&gt; {
 public T build();
}

USD buildCurrency(Builder<Builder&lt;? extends denomination>denomination&gt; currencyBuilder) { /* ... */ }

interface Thr<EXCThr&lt;EXC extends Exception>Exception&gt; {
    void fn() throws EXC;
}

public class UndeclaredGen {
  static void undeclaredThrow() throws RuntimeException {
    @SuppressWarnings("unchecked"&quot;unchecked&quot;)  // Suppresses warnings  
    Thr<RuntimeException>Thr&lt;RuntimeException&gt; thr = (Thr<RuntimeException>Thr&lt;RuntimeException&gt;)(Thr)
      new Thr<IOException>Thr&lt;IOException&gt;() {
        public void fn() throws IOException {
          throw new IOException();
	}
      };
      thr.fn();
    }

  public static void main(String[] args) {
    undeclaredThrow();
  }
}