CODEWITHSUNDEEP
java
mynameisJEFF
mynameisJEFF

Reputation: 4239

Java: Is it possible to throws IOException once and for all?

I am new to Java. And I find it really annoying to keep writing throws IOException in the "main" and all the methods that open a file. For example:

class something{    
    public static void main(String[] args) throws IOException{
            myobj abc = new myobj();
            abc.read_file("this_file.txt");
            abc.insert("text");
    }
}

class myobj{
            ....

           public void read_file(String file_loc) throws IOException{
                blablabla
            }
    }

In this case, I have already written "throws IOException" twice. Is there a way to handle this once and for all ?

Edit: Thanks for all the good answers. A lot of people suggested using try-catch statements. I read about try and catch statements and I got really confused. My question is where should I carry on writing my code i.e. abc.insert("text") into the try catch statements after abc.read_file("this_file.txt") ? Should I carry on in catch block or outside it ? This is what really puzzles me.

Upvotes: 1

Views: 1001

Answers (5)

luis.espinal
luis.espinal

Reputation: 10529

I am new to Java.

Hi, I hope you enjoy your learning. Learning a new programming language effectively implies learning the idiomatic ways in which to code in that language (even the ones that we subjectively find annoying.)

This is not unique to Java. Whether you do C# or Python or C++ or Haskell, you will be bound to find something that is annoying. Then the question is, what value do you get in the effort to avoid that annoyance.

If you become more productive by avoiding the annoyance, then more power to you. Otherwise, I would follow Maya Angelou's advice: "If you don't like something, change it. If you can't change it, change your attitude."

And I find it really annoying to keep writing throws IOException in the "main" and all the methods that open a file.

In real life development, you will be handling far more non-main exceptions that main ones (probably only one main.)

So what is the threshold, the ration of main/(all other functions) by which the annoyance is justifiable and constructive? One main and one function? One main and a dozen? One main and a hundred?

Of all the plumbing and elbow grease that needs to be done with Java, declaring exceptions on the main function is an exercise in emotion of very little use.

So take it with a grain of salt, but in my professional opinion (18 years, Java, C++, Python and a lot of other crap) is this: declare your exceptions, even on main.

Why? Because it is possible that other programs might invoke your main. That is, your Java program might be invoked from the console, or it might be embedded (invokable?) from another program.

I've done this a lot for testing or for developing systems that are embeddable. So, in this case, you want to declare those exceptions. However, since such a program is intended for standalone and embedded use, this is the general pattern I follow (java-like pseudocode, far more simplified than real-life code):

class UtilityDelegate {
    UtilitytDelegate(){ .... }

    void performWork(File f) throws IOException {
        // do something with file
    }
}

public class SomeUtility {
    public static void main(final String[] args) throws IOException {
        File f = null;
        try{
            // do something that could throw an exception
            f = new File(args[0]);
            performWork(f);
        } finally {
            // do necessary clean-up, if any, such as closing file handles,
            // sockets, flushing database changes, pray to Lord Xenu, whatever

            if( f != null ){
                try{
                    f.close();
                }catch (IOException e){
                    e.printStackTrace(); // or use a logging mechanism or whatever
                }
            }
        }
    }
}

Now, your program can be called from the command line:

java SomeUtility myfile

Or from another java class:

public class SomeUtilityClient{
    public static void main(final String[] args){
        // for brevity, I'm omitting the case when the utility might
        // call System.exit() itself.
        try{
            SomeUtility.main("a-pre-defined-filename");
        } catch(IOException e){
            someLog("call to utility failed, see exception", e);
            System.exit(-1);
        }
        System.exit(0);
    }
}

An argument could be made that such a java client should call the embedded program via another method name, not main. That is fair, and in many cases, it is the better approach.

But just consider this one reason or approach of why to declare your exceptions everywhere, even on your main.

Upvotes: 1

duffymo
duffymo

Reputation: 308938

Who is main throwing to? No one.

Java has checked and unchecked exceptions. Checked exceptions leave you no choice: you either have to catch them or add them to your method signature in a throws clause.

Unchecked exceptions don't require handling.

You always have the option of catching a checked exception and rethrowing it as a custom unchecked exception.

I'd write it this way:

class something{    
    public static void main(String[] args) 
        try {
            myobj abc = new myobj();
            abc.read_file("this_file.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class myobj{
            ....

           public void read_file(String file_loc) throws IOException{
                blablabla
            }
    }

Upvotes: 3

GlobalVariable
GlobalVariable

Reputation: 181

Simply put, no.

There are two ways to deal with exceptions:

  1. You either handle that exception in your current method (main in your case) by surrounding the API that throws the exception with try-catch and writing code in the catch block to handle it OR
  2. Add "throws IOException" on the method signature in which case you force the callers of your method to deal with it.

Upvotes: 0

JamesB
JamesB

Reputation: 7894

The main method doesn't need to throw anything.

class something{    
    public static void main(String[] args) 
        try {
            myobj abc = new myobj();
            abc.read_file("this_file.txt");
            System.exit(0);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}

I know you may find this language feature annoying but trust me, it is far less frustrating than managing code which does not propagate exceptions. You spend hours and hours wondering why your code is not doing something and then you stumble across this:

try {
    doSomethingImportant();
}
catch(Exception e) {
   // Nah can't be bothered
}

Upvotes: 1

T.J. Crowder
T.J. Crowder

Reputation: 1074989

There's no catch-all "all methods in this class throw this exception," you'll have to declare the exception on each method (e.g., read_file, etc.) or handle it within the method. This is the point of checked exceptions: To ensure that at each stage, it's clear where they may come from and where they're handled.

Note: main shouldn't throw, you should catch the exception and handle it.

Upvotes: 3

Related Questions