How to make java compiler ignore errors/warnings

Question

So I have the following bit of code:

 public static Image getImage(String filepath, Class cl) {
    try {
        return ImageIO.read(cl.getResource(filepath));
    }
    catch (IOException e) {
        e.printStackTrace();
    }

    return null;    // Will never execute
}

It's a basic try-catch block. If I am unable to read the image and return it, I immediately go into my catch block. However, because my return is within the scope of the try block and not the entire function, my compiler issues an error when I try to compile and run because it sees that it's possible that I never hit a return statement. Therefore, I've added the return null; line to suppress this warning, but I'd rather have a neater way of doing this without putting code that will never run. I've tried adding

@SuppressWarnings("all")

To my code, but it still gives me an error. Any ideas? I feel like there should be a way to tell the compiler to ignore errors like this.

Also, if it is of any use, I am using IntelliJ as my IDE.

Answer 1

I would suggest what @LuCio eagerly in the comments tried to say. Just don't catch the Exception and pass it upwards:

public static Image getImage(String filePath, Class<?> clazz) throws IOException {
    return ImageIO.read(clazz.getResource(filePath));
}

That way you have created an easy helper method. If you would return null, you'd have to document that in JavaDoc and every caller will have to use a not-null assertion logic to then throw an error if it is null.

A try catch block does the same. So instead of passing null upwards you just propagate the exception upwards. You somewhere said that you want to assign the Image to a static field, so you can do that easily like this:

static {
    try {
         MY_IMAGE = getImage("somepath", MyClass.class);
    } catch(IOException e){
        throw new IOError(e); // will kill the Vm with an error
    }
}

But maybe somewhere you have another action. Than to just kill the VM. Maybe use a default image:

final Image image;
try {
    image = getImage("somepath", MyClass.class);
} catch(IOException e){
    e.printStacktrace();
    image = new SomeDefaultImage();
}

// do something with image

Which all in all is the way to go. You can't have a helper method to decide what to do when it fails. That should always be done by the calling code.

Answer 2

Ok so, I believe I was confusing the purpose of the catch block. Thank you to @Ben and @Zephyr and everybody else for your help. I will be amending my code to:

public static Image getImage(String filepath, Class cl) {
    try {
        return ImageIO.read(cl.getResource("hello"));
    } catch (IOException e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
        throw new IOError(e);
    }
}

Edit: After some more discussions, and looking through other options other people have posted, I have updated my code above, which satisfies the compiler. Note that replacing the line

throw new IOError(e)

with

System.exit(0);

does not fix the error because, as far as I know, the compiler cannot tell at compile time whether the program would end. It would've been helpful to have a way of suppressing the warning, since we know that at runtime the program will always (or practically always) end, but alas @SuppressWarnings is of no use.