Exercise: Exceptions

Questions for: Exceptions

Which four can be thrown using the throw statement?
  1. Error
  2. Event
  3. Object
  4. Throwable
  5. Exception
  6. RuntimeException
A:
1, 2, 3 and 4
B:
2, 3, 4 and 5
C:
1, 4, 5 and 6
D:
2, 4, 5 and 6
Answer: C

The (1), (4), (5) and (6) are the only four that can be thrown.

An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

The Throwable class is the superclass of all errors and exceptions in the Java language.

The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch (checked exceptions)

RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.

📖
📝
💬
👁️ 
System.out.print("Start ");
try 
{
    System.out.print("Hello world");
    throw new FileNotFoundException();
}
System.out.print(" Catch Here "); /* Line 7 */
catch(EOFException e) 
{
    System.out.print("End of file exception");
}
catch(FileNotFoundException e) 
{
    System.out.print("File not found");
}
and given that EOFException and FileNotFoundException are both subclasses of IOException, and further assuming this block of code is placed into a class, which statement is most true concerning this code?
A:
The code will not compile.
B:
Code output: Start Hello world File Not Found.
C:
Code output: Start Hello world End of file exception.
D:
Code output: Start Hello world Catch Here File not found.
Answer: A

Line 7 will cause a compiler error. The only legal statements after try blocks are either catch or finally statements.

Option B, C, and D are incorrect based on the program logic described above. If line 7 was removed, the code would compile and the correct answer would be Option B.

📖
📝
💬
👁️ 
public class ExceptionTest 
{ 
    class TestException extends Exception {} 
    public void runTest() throws TestException {} 
    public void test() /* Point X */ 
    { 
        runTest(); 
    } 
}
At Point X on line 5, which code is necessary to make the code compile?
A:
No code is necessary.
B:
throws Exception
C:
catch ( Exception e )
D:
throws RuntimeException
Answer: B

Option B is correct. This works because it DOES throw an exception if an error occurs.

Option A is wrong. If you compile the code as given the compiler will complain:

"unreported exception must be caught or declared to be thrown" The class extends Exception so we are forced to test for exceptions.

Option C is wrong. The catch statement belongs in a method body not a method specification.

Option D is wrong. TestException is a subclass of Exception therefore the test method, in this example, must throw TestException or some other class further up the Exception tree. Throwing RuntimeException is just not on as this belongs in the java.lang.RuntimeException branch (it is not a superclass of TestException). The compiler complains with the same error as in A above.

📖
📝
💬
👁️ 
public class MyProgram 
{
    public static void throwit() 
    {
        throw new RuntimeException();
    }
    public static void main(String args[])
    {
        try 
        {
            System.out.println("Hello world ");
            throwit();
            System.out.println("Done with try block ");
        }
        finally 
        {
            System.out.println("Finally executing ");
        }
    }
}
which answer most closely indicates the behavior of the program?
A:
The program will not compile.
B:
The program will print Hello world, then will print that a RuntimeException has occurred, then will print Done with try block, and then will print Finally executing.
C:
The program will print Hello world, then will print that a RuntimeException has occurred, and then will print Finally executing.
D:
The program will print Hello world, then will print Finally executing, then will print that a RuntimeException has occurred.
Answer: D

Once the program throws a RuntimeException (in the throwit() method) that is not caught, the finally block will be executed and the program will be terminated. If a method does not handle an exception, the finally block is executed before the exception is propagated.

📖
📝
💬
👁️ 
import java.io.*;
public class MyProgram 
{
    public static void main(String args[])
    {
        FileOutputStream out = null;
        try 
        {
            out = new FileOutputStream("test.txt");
            out.write(122);
        }
        catch(IOException io) 
        {
            System.out.println("IO Error.");
        }
        finally 
        {
            out.close();
        }
    }
}
and given that all methods of class FileOutputStream, including close(), throw an IOException, which of these is true?
A:
This program will compile successfully.
B:
This program fails to compile due to an error at line 4.
C:
This program fails to compile due to an error at line 6.
D:
This program fails to compile due to an error at line 18.
Answer: D

Any method (in this case, the main() method) that throws a checked exception (in this case, out.close() ) must be called within a try clause, or the method must declare that it throws the exception. Either main() must declare that it throws an exception, or the call to out.close() in the finally block must fall inside a (in this case nested) try-catch block.

📖
📝
💬
👁️
Ad Slot (Above Pagination)
Quiz