Re: Why does Java require the throws clause? Good or bad language design?

On Tue, 20 Feb 2007, Michael Rauscher wrote:


   I /want/ to ignore the higherLevel method! Here's an analogy that
I think will be extremely clear to Lisp programmers, but maybe not to
C++/Java programmers: I can write

     for (...) {
        callbackFunc();
     }

instead of

     for (...) throws Exception {
        callbackFunc();
     }

Exceptions thrown by the inner callbackFunc() are quietly and
transparently passed out of the loop and up to the surrounding
context. So why can't I create my own "control structures" by
writing

     ... higherLevel(...) { ... }
     higherLevel(callbackFunc);

instead of

     ... higherLevel(...) throws Exception { ... }
     higherLevel(callbackFunc);


   Yes, agreed. (Of course, as a C programmer myself, I'd object that
the contract isn't "don't pass me 42", but "if you pass 42 I'll throw
an exception." If the caller broke the contract as you stated it above,
I wouldn't be so nice as to waste my time throwing him an exception. ;)


   Oops!


   You killed it, that's what happened! So clearly your way of
implementing higherLevel() is at fault. As the name "higherLevel"
implies, to me anyway, higherLevel() should pass exceptions through,
quietly and transparently, up to the surrounding context.


   Well, I put a 'catch' clause in my original C++ version, which is why
I made a big deal out of it. The Java was supposed to do the same thing
as the C++; that was the whole point!


   Right; and Java's unchecked exceptions do seem to solve the whole
problem.


   I just tested the code to make sure I wasn't mistaken --- I wasn't.
You get a compile-time error if you say:
(this is a complete translation unit):

interface CBF {
    public void execute(int x);
}

class Foo {
     public void higherLevel( CBF cbf, int arr[] ) {
         for (int i=0; i < arr.length; ++i)
           cbf.execute(arr[i]);
     }

     public void catcher()
     {
         int arr[] = new int[] { 1, 2, 3, 42, 5 };

         CBF callBackFunc = new CBF() {
             public void execute(int x) {
                 if ( x == 42 )
                   throw new Exception();
             }
         };

         try {
             higherLevel( callBackFunc, arr );
         } catch (Exception e) {
             // handle exception somehow
         }
     }
}

Now change it to

         CBF callBackFunc = new CBF() {
             public void execute(int x) throws Exception {
                 if ( x == 42 )
                   throw new Exception();
             }
         };

Still an error; 'execute' doesn't match the interface. Change it to

interface CBF {
    public void execute(int x) throws Exception;
}

Still an error; 'higherLevel' throws an undeclared exception. And now
we're borked, unless of...


   So let's make it

     public void higherLevel( CBF cbf, int arr[] ) throws Exception {
         for (int i=0; i < arr.length; ++i)
           cbf.execute(arr[i]);
     }

Now I see two problems, but one of them might be a mirage. That one
is: what happens if we want to use higherLevel() with a callback
function that might throw something /else/? We'd have to make it

     public void higherLevel( CBF cbf, int arr[] )
             throws Exception, SomethingElse {
         for (int i=0; i < arr.length; ++i)
           cbf.execute(arr[i]);
     }

And then if we want to throw a third thing,

     public void higherLevel( CBF cbf, int arr[] )
             throws Exception, SomethingElse, AThirdThing {
         for (int i=0; i < arr.length; ++i)
           cbf.execute(arr[i]);
     }

Basically, every time our client code changes, we have to go find
our library and patch it. That's not code reuse.
   Now, this "problem" is probably a mirage, because of the coincidence
that in Java, all checked exceptions derive from Exception (am I right?),
so we can just write "throws Exception" and we'll have covered all the
bases.

   The more serious problem is, what happens if catcher2() wants to
perform higherLevel() on callback2(), and this time the contract
between the *2() functions does /not/ involve any exceptions being
thrown?

interface CBF {
    public void execute(int x); // "throws Exception" or not, doesn't matter
}

class Foo2 {
     // This is the same higher-level library function, reused.
     // Pretend it's in a different translation unit.
     public void higherLevel( CBF cbf, int arr[] ) throws Exception {
         for (int i=0; i < arr.length; ++i)
           cbf.execute(arr[i]);
     }

     public void catcher2()
     {
         int arr[] = new int[] { 1, 2, 3, 42, 5 };

         CBF callBack2 = new CBF() {
             public void execute(int x) {
                return; // no exceptions here!
             }
         };

         higherLevel( callBack2, arr );
         // no need for a catch; callBack2 doesn't throw
     }
}

There's no way to make this code work, unless you are willing to do
one of three things:
   (1) Change the library; i.e., give up on code reuse.
   (2) Add spurious "catch" clauses to every use of 'higherLevel',
thus confusing the reader, since exceptions aren't being used in
this code.
   (3) Add spurious "throws Exception" clauses to every function
in the program and a "catch" in main, again confusing the reader,
but at least conserving the vertical space.

   Again I say: AFAICT, if you want C++-ish semantics in Java, you
use unchecked exceptions. There's no magic bullet in either language.
I appreciate your comment crossthread,


Truce? ;)

-Arthur