Java error unreported exception ioexception must be caught or declared to be thrown

Exceptions bubble up the stack. If a caller calls a method that throws a checked exception, like IOException, it must also either catch the exception, or itself throw it.

In the case of the first block:

filecontent()
{
    setGUI();
    setRegister();
    showfile();
    setTitle("FileData");
    setVisible(true);
    setSize(300, 300);

    /*
        addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent we)
            {
                System.exit(0);
            }
        });
    */
}

You would have to include a try catch block:

filecontent()
{
    setGUI();
    setRegister();
    try {
        showfile();
    }
    catch (IOException e) {
        // Do something here
    }
    setTitle("FileData");
    setVisible(true);
    setSize(300, 300);

    /*
        addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent we)
            {
                System.exit(0);
            }
        });
    */
}

In the case of the second:

public void actionPerformed(ActionEvent ae)
{
    if (ae.getSource() == submit)
    {
        showfile();
    }
}

You cannot throw IOException from this method as its signature is determined by the interface, so you must catch the exception within:

public void actionPerformed(ActionEvent ae)
{
    if(ae.getSource()==submit)
    {
        try {
            showfile();
        }
        catch (IOException e) {
            // Do something here
        }
    }
}

Remember, the showFile() method is throwing the exception; that’s what the «throws» keyword indicates that the method may throw that exception. If the showFile() method is throwing, then whatever code calls that method must catch, or themselves throw the exception explicitly by including the same throws IOException addition to the method signature, if it’s permitted.

If the method is overriding a method signature defined in an interface or superclass that does not also declare that the method may throw that exception, you cannot declare it to throw an exception.

1. Demonstration of Unreported IOException
2. Use try-catch to Catch Unreported IOException
3. Use the throws Keyword to Eradicate IOException

This tutorial demonstrates another compile time exception saying unreported exception ioexception; must be caught or declared to be thrown. We will also learn about its possible causes and solutions via sample programs.

Demonstration of Unreported IOException

Example Code:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class TestClass {

    public static void main(String[] args){
        BufferedReader inputFile = null;
        PrintWriter outputFile = null;
        String inputFileName = "C:\New folder\inputFile.txt";
        String outputFileName = "C:\New folder\outputFile.txt";
        try {
            inputFile = new BufferedReader(new FileReader(inputFileName));
            outputFile = new PrintWriter(new FileWriter(outputFileName));
            String lineOfText = inputFile.readLine();
            while (lineOfText != null) {
                if (lineOfText.contains("x")) {
                    lineOfText = lineOfText.replaceAll("x" + ".*", ""Updated"");
                }
                outputFile.println(lineOfText);
                lineOfText = inputFile.readLine();
            }
        } catch (IOException ioe) {
            System.err.println("Caught IOException: " + ioe.getMessage());
        } finally {
            if (inputFile != null) {
                inputFile.close();//<------This line causes this exception
            }
            if (outputFile != null) {
                outputFile.close();
            }
        }
    }
}

In the code above, we read data from the specified input file; look for the letter x. As soon as it is found, we replace the x and the upcoming text on the same line with the word Updated enclosed in double quotes (" ").

Finally, we close both files (input and output).

The line inputFile.close(); that we are pointing to in the above code example is causing an unreported IOException which must be caught or thrown. What does this mean?

It means the inputFile.close(); is causing the IOException that we can get rid of using the try-catch block (it’s called catching the exception) or using the throws keyword (it’s called exception is thrown). How to do it?

Let’s learn with code examples below.

Use try-catch to Catch Unreported IOException

Example Code:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class TestClass {

    public static void main(String[] args){
        BufferedReader inputFile = null;
        PrintWriter outputFile = null;
        String inputFileName = "C:\New folder\inputFile.txt";
        String outputFileName = "C:\New folder\outputFile.txt";
        try {
            inputFile = new BufferedReader(new FileReader(inputFileName));
            outputFile = new PrintWriter(new FileWriter(outputFileName));
            String lineOfText = inputFile.readLine();
            while (lineOfText != null) {
                if (lineOfText.contains("x")) {
                    lineOfText = lineOfText.replaceAll("x" + ".*", ""Updated"");
                }
                outputFile.println(lineOfText);
                lineOfText = inputFile.readLine();
            }
        } catch (IOException ioe) {
            System.err.println("Caught IOException: " + ioe.getMessage());
        } finally {
            if (inputFile != null) {
                try{
                    inputFile.close();
                }catch(IOException ioe){
                    System.err.println("Caught IOException: " + ioe.getMessage());
                }
            }
            if (outputFile != null) {
                outputFile.close();
            }
        }
    }
}

The input file has the following content.

this is x one file
this is x two file
this is x three file

After executing the program, we get an output file containing the content below.

this is "Updated"
this is "Updated"
this is "Updated"

Here, we eliminate the IOException using the try-catch block, where the try statement lets us define a specific block of code that needs to be examined for errors during the execution process.

If any exception occurs at any particular statement within the try block, it will stop execution and jump to the catch block. So, it is strongly advised not to keep the code within the try block that does not throw any exception.

On the other hand, the catch statement permits defining a block of code that needs to be executed if there is any error in the try block. The catch is written right after the try block.

We can also have multiple catch blocks based on how many exceptions we can get in the respective try block.

We can also write a customized message while handling the exception. Now, the question is how these exceptions are handled.

The Java Virtual Machine (JVM) checks whether an exception is handled or not. If it is not, the JVM serves with the default exception handler, which does a few tasks that are listed below:

• It prints the description of an exception in the program’s output console.
• It also prints the stack trace in the program’s output console. The stack trace is the methods’ hierarchy where an exception occurred.
• It results in the program’s termination.

On the other side, the application’s normal flow is maintained if an application programmer has handled the exception, which means the remaining code gets executed.

Use the throws Keyword to Eradicate IOException

Example Code:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class TestClass {

    public static void main(String[] args) throws IOException{
        BufferedReader inputFile = null;
        PrintWriter outputFile = null;
        String inputFileName = "C:\New folder\inputFile.txt";
        String outputFileName = "C:\New folder\outputFile.txt";
        try {
            inputFile = new BufferedReader(new FileReader(inputFileName));
            outputFile = new PrintWriter(new FileWriter(outputFileName));
            String lineOfText = inputFile.readLine();
            while (lineOfText != null) {
                if (lineOfText.contains("x")) {
                    lineOfText = lineOfText.replaceAll("x" + ".*", ""Updated"");
                }
                outputFile.println(lineOfText);
                lineOfText = inputFile.readLine();
            }
        } catch (IOException ioe) {
            System.err.println("Caught IOException: " + ioe.getMessage());
        } finally {
            if (inputFile != null) {
                inputFile.close();
            }
            if (outputFile != null) {
                outputFile.close();
            }
        }
    }
}

The content of an input file is as follows.

this is x one file
this is x two file
this is x three file

The output file has the updated content as given below.

this is "Updated"
this is "Updated"
this is "Updated"

This code is the same as the previous section, where we only use the try-catch block to handle the exception. Here, we are using throws to declare an exception; we can also declare multiple exceptions separated by a comma (,).

The throws keyword informs the application programmer that an exception may occur in this method. Remember, the throws keyword is written while defining the function (see in the given example code).

So, it is good and strongly advised that the programmer handle this exception in the code to maintain the normal execution flow. Otherwise, the program will terminate. Let’s understand it via example code.

Copy the following code and run it. Make sure we have an incorrect path for the input file.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class TestClass {

    public static void main(String[] args) throws IOException{
        BufferedReader inputFile = null;
        PrintWriter outputFile = null;
        String inputFileName = "C:\New folder\input.txt";
        String outputFileName = "C:\New folder\outputFile.txt";
        try {
            inputFile = new BufferedReader(new FileReader(inputFileName));
            outputFile = new PrintWriter(new FileWriter(outputFileName));
            String lineOfText = inputFile.readLine();
            while (lineOfText != null) {
                if (lineOfText.contains("x")) {
                    lineOfText = lineOfText.replaceAll("x" + ".*", ""Updated"");
                }
                outputFile.println(lineOfText);
                lineOfText = inputFile.readLine();
            }
        } catch (IOException ioe) {
            System.err.println("Caught IOException: " + ioe.getMessage());
        } finally {
            if (inputFile != null) {
                inputFile.close();
            }
            if (outputFile != null) {
                outputFile.close();
            }
        }
        System.out.println("Continue execution!");
    }
}

OUTPUT:

Caught IOException: C:New folderinput.txt (The system cannot find the file specified)
Continue execution!

We will see the output as given above. The program continues code execution because we have handled the exception.

Now, comment out the try, catch, and finally blocks as follows and rerun the code. Make sure we have an incorrect path for an input file.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class TestClass {

    public static void main(String[] args) throws IOException{
        BufferedReader inputFile = null;
        PrintWriter outputFile = null;
        String inputFileName = "C:\New folder\input.txt";
        String outputFileName = "C:\New folder\outputFile.txt";
        //try {
            inputFile = new BufferedReader(new FileReader(inputFileName));
            outputFile = new PrintWriter(new FileWriter(outputFileName));
            String lineOfText = inputFile.readLine();
            while (lineOfText != null) {
                if (lineOfText.contains("x")) {
                    lineOfText = lineOfText.replaceAll("x" + ".*", ""Updated"");
                }
                outputFile.println(lineOfText);
                lineOfText = inputFile.readLine();
            }
        //} catch (IOException ioe) {
        //    System.err.println("Caught IOException: " + ioe.getMessage());
        //} finally {
            if (inputFile != null) {
                inputFile.close();
            }
            if (outputFile != null) {
                outputFile.close();
            }
        //}
        System.out.println("Continue execution!");
    }
}

The program will terminate the execution as soon as it finds the exception and never reaches the following line of code.

System.out.println("Continue execution!");

This is the reason we handle our declared exceptions. Remember, we can only declare the checked exceptions because the programmer can handle the unchecked exceptions within the code.

Resolve Unreported Exception IOException Must Be Caught or Declared to Be Thrown in Java

This tutorial demonstrates another compile time exception saying unreported exception ioexception; must be caught or declared to be thrown . We will also learn about its possible causes and solutions via sample programs.

Demonstration of Unreported IOException

In the code above, we read data from the specified input file; look for the letter x . As soon as it is found, we replace the x and the upcoming text on the same line with the word Updated enclosed in double quotes ( » » ).

Finally, we close both files (input and output).

The line inputFile.close(); that we are pointing to in the above code example is causing an unreported IOException which must be caught or thrown. What does this mean?

It means the inputFile.close(); is causing the IOException that we can get rid of using the try-catch block (it’s called catching the exception) or using the throws keyword (it’s called exception is thrown). How to do it?

Let’s learn with code examples below.

Use try-catch to Catch Unreported IOException

The input file has the following content.

After executing the program, we get an output file containing the content below.

Here, we eliminate the IOException using the try-catch block, where the try statement lets us define a specific block of code that needs to be examined for errors during the execution process.

If any exception occurs at any particular statement within the try block, it will stop execution and jump to the catch block. So, it is strongly advised not to keep the code within the try block that does not throw any exception.

On the other hand, the catch statement permits defining a block of code that needs to be executed if there is any error in the try block. The catch is written right after the try block.

We can also have multiple catch blocks based on how many exceptions we can get in the respective try block.

We can also write a customized message while handling the exception. Now, the question is how these exceptions are handled.

The Java Virtual Machine (JVM) checks whether an exception is handled or not. If it is not, the JVM serves with the default exception handler, which does a few tasks that are listed below:

• It prints the description of an exception in the program’s output console.
• It also prints the stack trace in the program’s output console. The stack trace is the methods’ hierarchy where an exception occurred.
• It results in the program’s termination.

On the other side, the application’s normal flow is maintained if an application programmer has handled the exception, which means the remaining code gets executed.

Use the throws Keyword to Eradicate IOException

The content of an input file is as follows.

The output file has the updated content as given below.

This code is the same as the previous section, where we only use the try-catch block to handle the exception. Here, we are using throws to declare an exception; we can also declare multiple exceptions separated by a comma ( , ).

The throws keyword informs the application programmer that an exception may occur in this method. Remember, the throws keyword is written while defining the function (see in the given example code).

So, it is good and strongly advised that the programmer handle this exception in the code to maintain the normal execution flow. Otherwise, the program will terminate. Let’s understand it via example code.

Copy the following code and run it. Make sure we have an incorrect path for the input file.

We will see the output as given above. The program continues code execution because we have handled the exception.

Now, comment out the try , catch , and finally blocks as follows and rerun the code. Make sure we have an incorrect path for an input file.

The program will terminate the execution as soon as it finds the exception and never reaches the following line of code.

This is the reason we handle our declared exceptions. Remember, we can only declare the checked exceptions because the programmer can handle the unchecked exceptions within the code.

Mehvish Ashiq is a former Java Programmer and a Data Science enthusiast who leverages her expertise to help others to learn and grow by creating interesting, useful, and reader-friendly content in Computer Programming, Data Science, and Technology.

Источник

Recommended Answers

All 17 Replies

try
{
    methodThatMightThrowExceptionA();
}
catch(ExceptionA e)
{
    whatIWantToDoIfExceptionAHappens();
}

public void methodThatDoesNotCatch() throws ExceptionA
{
    methodThatMightThrowExceptionA();
}

I have followed your explanation, and the program compiled, but now it is throwing a nullpointerexception error in the main class Game:

boolean finished = false;
        while (! finished) {
            Command command = parser.getCommand();
            String input = command.getCommandWord() + command.getSecondWord();
            logger.logToFile(input); //the error
            finished = processCommand(command);

        }
        logger.closeStream();
        System.out.println("Thank you for playing.  Good bye.");
}

i have added try and catch for both the writing and closing of the file in the logger class. 

from what i understand about the error, it means that I am passing a null to the logger.lotToFile(input) method, but not sure why!

thank you for the help!

public class Logger {
  private BufferedWriter out;
  public Logger() throws IOException {
    fw = new FileWriter("logfile.txt");
    bw = new BufferedWriter(fw);
  }

  public void logToFile(String input) throws IOException {
    this.input = input;   // <--- Where did you declare 'input' variable of the class?
    bw.write("User Input: " + input + "n");
  }

  public void closeStream() {
    bw.close();
  }
}

this is the source code for logger:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * Write a description of class Logger here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Logger
{
    // instance variables - replace the example below with your own
    private BufferedWriter bw;
    private String input;  //declared in here


    /**
     * Constructor for objects of class Logger
     */
    public Logger() throws IOException
    {
        //
        FileWriter fw = new FileWriter("logfile.txt");

        //
        BufferedWriter bw = new BufferedWriter(fw);


    }

    /**
     * 



     */
    public void logToFile(String input) 
    {
        this.input = input;
        try
        {

            bw.write("User Input:  " + input + "n");
            // put your code here
        }
        catch (IOException ioe)
        {
            ioe.printStackTrace();
        }
    }


    public void closeStream()
     {
        try
        {
        bw.close();
        }
        catch (IOException ioe)
        {
        ioe.printStackTrace();
        }
    }
}

Command command = parser.getCommand();

public void logToFile(String input) {
  System.out.println("In logToFile()");
  this.input = input;
  try {
    System.out.println("In try");
    bw.write("User Input: " + input + "n");
    System.out.println("Pass the try");
  // put your code here
  }
  catch (IOException ioe) {
    System.out.println("Failed, in IOException");
    ioe.printStackTrace();
  }
  catch (Exception e) {  // I add this to catch all other Exception
    System.out.println("Unknow exception thrown!");
    e.printStackTrace();
  }
}


boolean finished = false;
System.out.println("Start checking");
while (! finished) {
  System.out.println("Not done");
  Command command = parser.getCommand();
  System.out.println("Got command: "+(command==null ? "NULL" : "OK"));
  String input = command.getCommandWord() + command.getSecondWord();
  System.out.println("Got input: "+(input==null ? "NULL" : "OK"));
  logger.logToFile(input); //the error
  System.out.println("Logged successfully");
  finished = processCommand(command);
  System.out.println("Recheck again");
}
System.out.println("Closing the stream");
logger.closeStream();
System.out.println("Closed the stream");
System.out.println("Thank you for playing. Good bye.");

it is a very smart way! i added a print out for the "input" string, i got this:

You are outside the main entrance of the university.
Exits:  south east west
sTARET CHECKING
NOT DONE
> go south
got command: OK
Got input: OK
gosouth

the error line:

Command command = parser.getCommand();
            System.out.println("got command: "+ (command==null ? "NULL" : "OK"));
            String input = command.getCommandWord() + command.getSecondWord();
            System.out.println("Got input: "+(input==null ? "NULL" : "OK"));
            System.out.println(input);
            logger.logToFile(input); // here is the error
            System.out.println("Logged successfully");
            finished = processCommand(command);
            System.out.println("Recheck again");

even when I removed logger.logToFile(input); and kept the .close(); line, i got the same error!

no, the Logger instance wasnt initiated @_@'' !!! thanks Taywin :)

for some reason, I get "unknown exception thrown" should I get red of 
catch (Exception e) {
.....
}
? or something else went wrong? I still dont know where the file is saved!

is this the stack trace:
"t __SHELL1.run(__SHELL1.java:8)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:601)
    at bluej.runtime.ExecServer$3.run(ExecServer.java:725)" ?

I dont know if it has the permission! didnt do anything about that,,,

Reply to this topic