Unhandled exception type Exception in Eclipse

I have the class Parser in Java like below:

public class Parser {
public ArrayList<MetroStop> listeArrets;

public Parser() {
	this.listeArrets = new ArrayList<>();		
}

public MetroStop creerArret(String [] parts) {
	MetroStop arret = new MetroStop ();	
	arret.identifiant = Integer.parseInt(parts [0]);
	arret.longitude = Double.parseDouble(parts [1]);
	arret.latitude = Double.parseDouble(parts [2]);
	arret.nom = parts [3];
	arret.destination = parts [4];
	arret.moyen = parts [5];
	return arret;
}

public  void  parse(String fichier)  throws  Exception {
	try {
		Reader reader = new FileReader(fichier);
		BufferedReader  br = new  BufferedReader(reader);
		String line;	
		while((line = br.readLine ()) != null) {
			String [] parts = line.split("#"); 
			MetroStop arret = creerArret(parts);
			listeArrets.add(arret);		
		}
		br.close();
	} catch (FileNotFoundException e) {
        throw new RuntimeException(e);		
    }
}

}

I also have the Main class:

public class Main {
public static void main(String[] argv) {	
	Parser teste = new Parser();
	teste.parse("ratp_arret.csv");
}

}

When I run the Main class as Java Application i get this error:
"Unhandled exception type Exception", which points to the second line of the main() method.
The file ratp_arret.csv is located in the src folder, which is also the working directory.I am using Eclipse.
I don't understand where this error comes from.
Thank you for your help!

You call teste.parse(someString), where teste is an expression which has type Parser. That means this is a call to the method parse(String) in your Parser type....

and that is declared with throws Exception.

Exceptions are a mechanism to convey alternate return options. The parse method can run its course in one of two ways: It can 'return', in which case it returns nothing (void), or, it can 'throw'. What it can throw is limited by its throws line - in this case, it can throw just about anything (Exception is the supertype of almost all things you can throw).

The way java handles this is that your code needs to handle every possible way a method can conclude.

So, you need a 'path' for your code when the parser() method returns (this is trivial; it's a void method, you get that 'for free', you don't need to write anything special for this), but you also need a path for that other exit scenario: When it throws something. You get handling of RuntimeException for free, but for others, you have two options:

catch it:

try {
    teste.parse(someString);
    // this code runs in the 'return' case.
} catch (Exception e) {
   // this code runs in the 'throws' case.
}

this would imply you know what to do when your parse method decided to exit via the throws path.

Alternatively, you fix this by having your main method also 'fork', and decree that it has two ways to finish: Either via the return route or the throw route:

public static void main(String[] args) throws Exception {
    teste.parse(someString);
}
// this main method has declared that it has two separate
// exit routes. 'return', and 'throws something'.

java will start an application by running its main method, and java can deal with a main that has two alternate exit routes (return, or throw something). It handles the 'return' route by doing nothing. It handles the 'throw something' route by printing the type of the exception, the message, the stack trace, and the entire causal chain. That is an excellent default, and you should not attempt to come up with a different one by e.g. catching that exception and attempting to 'log it'.

This: Just add throws Exception to your main method declaration. Put the throws Exception back on your parse method, ignore @Eritrean's advice.

NB: All methods are inherently declared as if they said throws RuntimeException, Error (as in, any error and any runtimeexception can be thrown without writing a throws clause for it, as all methods implicitly have that clause baked in already), this is why I said earlier that RuntimeExceptions are 'handled for free'. The idea is that all exceptions that subclass RuntimeException are things that are so universal or so unlikely, it would be unwieldy to force management of this onto the programmer. That's why you never need to write throws NullPointerException or throws InternalError.

public  void  parse(String fichier)  /*throws  Exception*/ {
    try {
        // ...
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);      
    }
}

You throw RuntimeException. This is called not-checked exception and it's not mandatory to declare these exeptions in the method declaration and catch it when calle the method.