Overriding doubt

[Nik Arora]

Hi All,
Can anybody explain me the below mentioned statements with a example.

1.The overriding method must not throw checked exceptions that are new or broader than those declared by the overridden method.

2.The overriding method can throw narrower or fewer exceptions.



Thanks All
Arora

[Chandra Bhatt]

Originally posted by nik arora:
Hi All,
Can anybody explain me the below mentioned statements with a example.

1.The overriding method must not throw checked exceptions that are new or broader than those declared by the overridden method.

2.The overriding method can throw narrower or fewer exceptions.

Thanks All
Arora

import java.io.*;
 
class Animal {
  void eat() throws IOException(}
  void sleep() throws EOFException{}
  void drink() {}
  void go() throws Exception{}
}
 
class Dog extends Animal {
  void eat() throws FileNotFoundException {} //OK, this is subclass of
//IOException
 void sleep() {} //does not throw the exception, what parent throws
 void drink() throws NullPointerException,ArithmeticException{}
//throws Uncheckexd exceptions that are not thrown by the parent class method, no problem 
 void go() throws Throwable {} //ERORR, overriding method can't throw broad 
//exception, Throwable is parent class of Exception
}

[Nik Arora]

Thanks chandra and one more doubt. If a class implements interface the explanation what you gave remains same to interfaces also.

[Chandra Bhatt]

Yeah Nikhil! That is true!

See the description code below, you will have some more idea regarding that!

package abstractway;
 
import java.io.*;
 
interface Modifiable {
void modify() throws IOException; //checked exception
}
 
interface Readable {
void readit() throws ClassNotFoundException; //checked exception
}
 
public class Program implements Modifiable, Readable{

public void modify() throws FileNotFoundException{
System.out.println("Modifying");
}
public void readit() throws IllegalArgumentException{
System.out.println("reading...");
throw new NumberFormatException(); //subclass of IAE
}

public static void main(String... args) {
Program p1 = new Program();
try{
p1.modify();
}catch(FileNotFoundException fnfe) {
System.out.println("FNFE what implemeting class says " +
"because the method was called from the class " +
"reference variable. No bother what interface says");
}

Modifiable m = p1;
try{
m.modify();
}catch(IOException ioe) {
System.out.println("IOException what interface Modifiable " +
"says, because the method was accessed using interface" +
"reference variable");
}



p1.readit(); //Need not handle or declare, because 
//accessed using class ref variable and that says to
//throw unchecked exception

Readable r = p1;
try{
r.readit();
}catch(ClassNotFoundException cnfe) {
System.out.println("Must catch it, or declare in the main" +
" because the interface says it throws the " +
" CNFE exception");
}
}

[Burkhard Hassel]

Hi ranchers,

two remarks:
the fact that the overridden method may throw narrower exceptions includes the case that it may not throw any exception at all.
And be carefull when you use these methods polymophically. For the exception to be handled (or not) only the reference type counts, not the actual type of the object.

class One {
void foo() throws Exception {
}
}
 
class Two extends One {
@Override
void foo() {
System.out.println("without exception");
}
}
 
public class Main {
public static void main(String[] args) {
Two two = new Two();
// "too too too" says the locomotive
two.foo();

// but this needs a try-catch
One poly = new Two();
try {
poly.foo();
} catch (Exception e) {
System.out.println("you won't read this");
}
}
}

prints
without exception
without exception


Yours,
Bu.

[Nik Arora]

Thanks Hassel and Chandra

[Nik Arora]

Hi Hassel and chandra,
What about Runtime Exception?

[Burkhard Hassel]

The same is true for RuntimeExceptions. Only difference is they are no checked exception, so they don't need to be declared or handled.

Bu.

[Nik Arora]

Hi Hassel,
Can you give me a example please?

[Nik Arora]

Hi Chandra,
p1.readit(); //Need not handle or declare, because //accessed using class ref variable and that says to//throw unchecked exception

I didnot get the above statement please explain

[Chandra Bhatt]

Originally posted by nik arora:
Hi Chandra,
p1.readit(); //Need not handle or declare, because //accessed using class ref variable and that says to//throw unchecked exception

I didnot get the above statement please explain

class Program implements Modifiable, Readable {
public void readit() throws IllegalArgumentException{
System.out.println("reading...");
throw new NumberFormatException(); //subclass of IAE
}
 
...
...
}

Modifiable interface readit() declares the IOException that it throws
it. IOException is the checked exception. The implementing class Program is
free to declare that exception in the method or not. But it can't
throw wider or new checked exception. What can it only throw are:

1- The same exception thrown by the interface method
2- Or subclass of it
3- Or unchecked exceptions. (any number of)

In our case we say that we will will implement the interface method readit()
following 3rd case.

Important Line:Whether the exception to be handled (or not) only the reference type matters, not the actual type of the object. [/b]

p1.readit();

p1 is the reference variable of the Program class, Program class implements the method readit() with unchecked exception. So I said we need not to declare or handle it. (Because compile can only see at the reference type,
reference type method does not throw the checked exception, so no problem of handling or declaring it). OK?

We have to bother about handling or declaring rule when the reference type is interface Modifiable; Because Modifiable says that readit() throws IOException (check exception)

Modifiable m1;
m1.readit(); //ERROR, you must handle or declare it (in our case main() method should declare it or place this statement inside the try catch )

[Nik Arora]

Hey got it and anything else if you know regarding this please share