Java back in the 1930s.

Consider the following interface:

public interface X
{
   public void doSomething() 
}

and two implementations:

public class Good implements X
{
   public void doSomething() { ; } 	
}

public class Bad implements X
{
   public void doSomething() { throw new RuntimeException(""); } 	
} 

Let's have a convenience class ExcpnChecker with just one static method to check whether a given implementation of X is going to throw an exception or not.

public final class ExcpnChecker
{
   public static boolean isThrowingException(X x) 
   { 
      try
      {
         x.doSomething();
         return false; 
      }
      catch (Exception e)
      {
         return true; 
      }
   }
}

such that:

ExcpnChecker.isThrowingException(new Good()); // returns false
ExcpnChecker.isThrowingException(new Bad());  // returns true

Consider now a third implementation of the X interface:

public class Pun implements X
{
   public void doSomething()
   { 
      if (ExcpnChecker.isThrowingException(this)) return;
      else throw new RuntimeException();       
   }  
}

can you tell what we get from

ExcpnChecker.isThrowingException(new Pun()); 

Now, think...

To see a short explaination highlight (select) the text below:


Although the method isThrowingException seems correct, it is not.
For example, it is not capable to handle the case of some X implementations which refer to itself, as we have shown with Pun.
Moreover, it is not able to handle other cases such as this:

public class Forever implements X
{
   public void doSomething() { while(true) { ; } }
}