how to return FileInputStream ?? in java

Question

package asasaSASA;

import java.io.*;

class FileInputTest {
    public static FileInputStream f1(String fileName) {
        try {
            FileInputStream fis = new FileInputStream(fileName);
            System.out.println("f1: File input stream created");
            return fis; // I HAVE RETURN fis
        }
        catch (FileNotFoundException e) {
            System.out.println("에러는"+e);
        }
    }

    public static void main(String args[]) {
        FileInputStream fis1 = null;
        String fileName = "foo.bar";
        System.out.println("main: Starting " + FileInputTest.class.getName()
                                                   + " with file name = " + fileName);
        fis1 = f1(fileName);
        System.out.println("main: " + FileInputTest.class.getName() + " ended");
    }
}

I want to make this code run but it said

This method must return a result of type FileInputStream

I can't understand because I made return fis. Why does it say that you have to return? I already returned it!

Answer 1

FileInputStream fis = new FileInputStream(fileName);

If the above line throws a FileNotFoundException then the next line of your code that will be executed is

System.out.println("에러는"+e);

which means it bypasses your return statement and that's why you are getting the compiler error.

There are many different ways to fix the compiler error and the other answers explain the different ways. I'm just answering your question, namely

Why does it say that you have to return?

I hope you understand now why you are wrong when you say

I already returned it!

Answer 2

Your method throws a checked exception which must be handled either inside of the method, or outside. Checked exception are to indicate that a problem may occur and you need to implement something to handle this scenario. Here we are worried that the file does not exist.

You have three Choices:

1. Return and handle value for not existing file (no exception is thrown here). So either return null, then check in main() that inputStream is not null, or return Optional<>, which is a JDK8 way to handle such scenarios.

Example:

 public static FileInputStream f1(String fileName) {
  try {
    FileInputStream fis = new FileInputStream(fileName);
    System.out.println("f1: File input stream created");
    return fis;
  } catch(FileNotFoundException e) {
     System.out.println("Error "+e);
     return null; // in case of not existing file
  }
 }

2. Wrap your checked FileNotFoundException into a custom RuntimeException. This will solve your problem with compile error, but may cause problems in the future if you will not catch this exception somewhere.

Example:

 public static FileInputStream f1(String fileName) {
  try {
    FileInputStream fis = new FileInputStream(fileName);
    System.out.println("f1: File input stream created");
    return fis;
  } catch(FileNotFoundException e) {
     System.out.println("Error "+e);
     throw new RuntimeException(e);
  }
 }

3. Instead of try-catch add this exception to your method signature:

Example:

  public static FileInputStream f1(String fileName) throws FileNotFoundException{
    FileInputStream fis = new FileInputStream(fileName);
    System.out.println("f1: File input stream created");
    return fis;

 }

But if you declare a checked exception in a method at some point you will have to catch it and handle.

Option 3 is most desired.

Answer 3

Your exception handling is the problem. It's common, but bad code style: Whenever you catch an exception, the right move is to either deal with that exception, or, to ensure that you (re)throw some exception.

Log it, or print it? That is not handling an exception.

In this case, 'file not found' is not something you can be expected to handle; not unless you expand on what f1 is supposed to do (tip: Methods should be a bit more descriptive than that). Thus, throwing something is fair game. Furthermore, the very definition of f1 (presumably; that name is not particular enlightening and the method has no documentation) suggests that 'open this file' is a fundamental aspect of it, and therefore, throwing a FileNotFoundException is fair as well.

Thus:

Best solution

public static FileInputStream f1(String fileName) throws IOException {
 FileInputStream fis = new FileInputStream(fileName);
 System.out.println("f1: File input stream created");
 return fis;
}

public static void main(String[] args) throws Exception {
String fileName = "foo.bar";
 System.out.println("main: Starting " + FileInputTest.class.getName()
 + " with file name = " + fileName);
 try (InputStream in = f1(fileName)) {
    // you must close any resources you open using a try-with-resources
    // construct; you did not do that in your code, I fixed this.
 }
}

NB: your psv main can (and generally should!) be declared to throws Exception.

Alternate take

This one works in any scenario where you cannot throws the exception, or if adding that the signature makes no sense because it reflects an implementation detail and not an inherent aspect of what the method is trying to do:

public static FileInputStream f1(String fileName) {
 try {
   FileInputStream fis = new FileInputStream(fileName);
   System.out.println("f1: File input stream created");
   return fis;
 } catch (IOException e) {
   throw new RuntimeException("Unhandled", e);
 }
}

Naturally, this is only appropriate for situations where you really don't expect that exception to occur under normal circumstances. Otherwise, either throw that exception onwards or make your own exception type and throw that instead of RuntimeException.

If you just need a ¯\(ツ)/¯ I don't really know what this means, I just want to move on and get rid of these exceptions solution: throw new RuntimeException("Uncaught", e); is correct; e.printStackTrace(); is incorrect. Update your IDE's templates.