Exception handling woes

[ineedahero]

Ok, so I'm trying to work with files, and with files come exception handling, and with exception handling comes compilation errors!

I have part of a function here that is used to retrieve information about a player. This information is in a file. I passed the name of the file that this information is in, it's under the variable "file".

This code is supposed to catch an error if the passed argument "file" doesn't actually exist.

Except this won't compile!!!! Why not?

                Scanner inputFile;
 
                String name = input.next();
 
                // exception handling
                try
                {
                        inputFile = new Scanner(file);
 
                } catch (FileNotFoundException ex)
                {
                        System.err.println("FileNotFoundException: " + ex.getMessage());
                }
 
                 // find player in file
                while(inputFile.hasNext() && !nameFound)
                {
                        fileName = inputFile.next();
 
                        System.out.println("fileName = " + fileName);
 
                        if (fileName.equals(name))
                                nameFound = true;
                }
 
                inputFile.close();

Here's the error:

TicTacToe.java:152: error: variable inputFile might not have been initialized
                while(inputFile.hasNext() && !nameFound)

[GregBrannon]

Simply initialize it when you declare it.

Scanner inputFile = null;

You can learn more about why this is important and why it's necessary by reviewing the tutorial on Java variables.

[KevinWorkman]

The problem occurs when you encounter a FileNotFoundException. In that case, your inputFile variable will not be initialized. So what should happen when you go to use it?

[ineedahero]

Ok guys, thanks for the help.

I fixed the errors, but now I'm getting more exception handling problems!

public Player createNewPlayer(java.io.File file)// throws Exception
        {
                Player player = new Player();
                java.io.FileWriter output = null;
 
                try
                {
                        output = new java.io.FileWriter(file, true);
 
                } catch (FileNotFoundException ex)
                {
                        System.err.println("FileNotFoundExcpetion: " + ex.getMessage());
 
                } catch (IOException ex)
                {
                        System.err.println("Caught IOException: " + ex.getMessage());
                }
 
                // receive player info
                player.receiveName();
                player.receiveSymbol();
 
 
                // write player information to file
                output.write(player.name + " " + player.symbol + " " + player.numWins + " " + player.numLosses + "\n");
 
                output.close();
 
                return player;
        }

Here's the error:

TicTacToe.java:209: error: unreported exception IOException; must be caught or declared to be thrown
                output.write(player.name + " " + player.symbol + " " + player.numWins + " " + player.numLosses + "\n");
                            ^
TicTacToe.java:211: error: unreported exception IOException; must be caught or declared to be thrown
                output.close();

I'm confused because this time it's all initialized; my previous code works perfectly. This one should be the same exact thing....but it isn't. I don't see why anything is wrong with those lines. I already reported the exception IOException up at the top....

[KevinWorkman]

You're only checking a single line in your try block above. What happens if you encounter the Exception on one of the lines not inside the try block?

[ineedahero]

So every single time I output something to a file I have to check for exception handling? Isn't that a little redundant?

And can I presume that the same holds for reading from a file?

[GregBrannon]

Redundant? Error checking must be as frequent as the possibility of the error occurring. Typically, reading and writing to a file is done in loops, and the entire loop can be enclosed in a try/catch block, so REALLY, only one try/catch block should be required for each of the reading and writing loops. Both reading and writing could be contained in the same try/catch block with multiple "catches," but that may not be a good design.

[ineedahero]

Ah, so it looks a little more like this:

Player player = new Player();
                java.io.FileWriter output = null;
 
                // receive player info
                player.receiveName();
                player.receiveSymbol();
 
                try
                {
                        // assign FileWriter object to the specified file
                        output = new java.io.FileWriter(file, true);
 
                        // write info to the file
                        output.write(player.name + " " + player.symbol + " " + player.numWins + " " + player.numLosses + "\n");
 
                        // close the file
                        output.close();
 
                } catch (FileNotFoundException ex)
                {
                        System.err.println("FileNotFoundExcpetion: " + ex.getMessage());
 
                } catch (IOException ex)
                {
                        System.err.println("Caught IOException: " + ex.getMessage());
                }
 
                return player;

Very nice. So I suppose every when you write to a file, even if it's like the ninth time in a row, it's always possible that a weird error comes out of nowhere.

Thank you for your help.

[KevinWorkman]

I agree with what Greg said, but to show you why you need to error-check almost every method involving files:

Java opens a file for reading or writing. Everything is okay. By your logic, we can be done error handling.
But what if the user goes and deletes that file before the next line? Remember that users are nefarious and will do everything they can to break your program. What if the permissions on the file changes? What if the hard drive fills up when you're writing to the file? So much can go wrong, so you need to have error checking.

[ineedahero]

Eh, bit of a typo there. The word "every" shouldn't be in the second sentence.

How come the edit button doesn't work? I click it and that loading circular icon thing comes up, and nothing ever happens.

[KevinWorkman]

Forum bug. Try opening it in a new tab.

[ineedahero]

While we're here, I figure I'll ask another question that's been on my mind about exception handling.

My professor mentioned that we should use exception handling in two scenarios (given the program we're working on):
1. Memory allocation
2. Accessing a file

I got the second one down, no problem.

The first one is a little more confusing.
By memory allocation, I'm assuming what's meant is every time you use the keyword "new".
So, like:

inputFile = new Scanner(file);

And in that case, I just check to see if the file is found.

But what about this line of code? Player is a class I created. Player player is just me creating a Player object named player.

Player player = new Player();

My question is this: in that line of code, I undoubtedly allocate memory....so is any exception handling necessary? And, if so, what exception do I throw?

Thanks in advance.

[GregBrannon]

Memory allocation? Every time a variable or object is declared, memory is allocated to store that item. That is done behind the scenes without programmer intervention. Would I expect anyone to put every variable declaration inside a try/catch block? Of course not. I'm not even sure what exception would be caught, but there's probably some obscure one I don't know about.

Beyond that, there are no programmer specific tools in Java for reserving or allocating blocks of memory that i can think of, so I'm not sure what your professor is talking about. You should ask.

[KevinWorkman]

I again agree with what Greg said. But to add to that, exception handling doesn't really have anything *specifically* to do with either file handling or memory allocation (whatever that means).

In Java, a method can declare the fact that it throws an Exception. There are two types of Exceptions: checked and unchecked. If a method has declared that it can throw a checked Exception (such as IOException), then the call to that method must be inside a try block (or you must delclare that method throws the Exception as well). Something like this:

import java.io.IOException;
 
public class Main {
 
	public static void main(String... args){
		try {
			doSomethingDangerous();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
	}
 
	static void doSomethingDangerous() throws IOException{
		if(Math.random() < .5){
			//this is not a good use of IOException but demonstrates the point
			throw new IOException();
		}
	}
}

The classes you're using, such as Scanner, are really just Java code. In fact you can look at the code in the src.zip file that comes with your JDK. If you look at the source for Scanner, you'll see that some of its methods have declared that they can throw an IOException, so you have to put them in a try block.

Similarly, you would only have to put a constructor in a try block if it declared that it threw a checked exception.