Your last solution, to use specific exceptions, would be more readable but could result in a lot of Exception subclass.

Here is a quick code update :

public static void main(String[] args) {
    try {
        String filePath = getFilePath(args);
        AtomicReference<String> content = new AtomicReference<String>();
        content.set(readYamlFile(sourceFilePath));
        jsonStr = convert(content.toString());
    }  catch (FileNotFoundException e) {
        System.out.println("not found");
    } catch (ReadYamlFileException e) {
        System.out.println("Not able to load file");
    } catch (ConvertJsonExceptione) {
        System.out.println("Conversion failed ");
    }
}

private String readYamlFile(String) throws ReadYamlFileException{ ... }
private String convert(String) throws ConvertJsonException{ ... }

Since I try to have the return statements in the beginning (filter parameter) or the end of a method (correct method execution), this design is useful. If not, we would have multiple line that could stop a process, leading to a complicated debugging.

EDIT:

Of course, if you only need to print a text and stop there (no exception management), you can simply create your own exception in each method :

private String readYamlFile(String) throws IOException {
    try{
       ...
    } catch (IOException e) {
        throw new IOException("Not able to load file", e);
    }
}

Where e is the original Exception thrown

I would say that this isn't controlling the flow of your application. This is handling an exceptional circumstance (i.e., failure of your code to perform what as it's meant to), which is what Exceptions are meant to accommodate.

The recommendation is more for circumstances like this:

public boolean itemExists(List<MyObject> list, MyObject object) {
    try {
        for(MyObject thisOne : list) {
            if(thisOne.getAttribute() == object.getAttribute()) {
                throw new Exception("found it");
            }
        }
    }
    catch(Exception e) {
        if(e.getMessage().equals("found it")) {
            return true;
        }
        throw e;
    }
    return false;
}

This controls the flow of the program based on normal execution. It should be pretty easy to see why this isn't ideal, simply for code readability, not considering aspects like performance, style, and best practices.

What you have in the above code is fine. Throwing Exceptions for errors is what they're for. If you're throwing Exception simply to break out of loops or functions or are using them during the "intended" execution of your code, that's when you're going down the wrong path.

I figured out what and how to do what I was needing. What I needed to stop the creation of the routine object if conditions were met, and that was done by throwing an error. That was being done, but I was mistakenly setting the variables INSIDE the try...catch block. So, if the conditions are not satisfied, it fails and stops, if they are satisfied, it creates the object and sets the variables OUTSIDE of the try...catch block, which works. My new code is as follows:

package routines;

import java.io.IOException;
import java.util.Random;

import game.*;

public class MovePlayer extends Routine {

    private final int destX;
    private final int destY;
    private final Random random = new Random();

    public MovePlayer(int destX, int destY, GameBoard board) throws IOException {
        super();
        try {
            if (destY > board.getHeight() || destX > board.getWidth()) {
                throw new IllegalArgumentException(">>> Error while creating routine, one or more coords are outside of the game board");
            } else {
            }
        } catch (IllegalArgumentException e) {
            fail();
        System.err.println(e.getLocalizedMessage());
    }
    this.destX = destX;
    this.destY = destY;
}

You don't need to catch the exception after it is thrown. If you catch it there, the program will start executing the statements that are there after the catch block.

System.out.println("Executing ");
if(1 == 1) // I put this 'if' here so that the code compiles
{
     throw new RuntimeException("This is thrown intentionally");
}
System.out.println("Must not execute");

The return statement will not run if the exception is thrown. Throwing an exception causes the control flow of your program to go immediately to the exception's handler(*), skipping anything else in the way. So in particular msg will be null in your print statement if an exception was thrown by showMsg.

(*) Except that statements in finally blocks will run, but that's not really relevant here.

If you throw the exception, the method execution will stop and the exception is thrown to the caller method. throw always interrupt the execution flow of the current method. a try/catch block is something you could write when you call a method that may throw an exception, but throwing an exception just means that method execution is terminated due to an abnormal condition, and the exception notifies the caller method of that condition.

Find this tutorial about exception and how they work - http://docs.oracle.com/javase/tutorial/essential/exceptions/

speakToPerson2() is catching the Exception, but you want communicate() to catch it too. Essentially, speakToPerson2() is suppressing the exception, so no other method sees it.

What you need to do is rethrow it (in both speakToPerson2() and speakToPerson3()). This is known as propagating an exception.

I.e.:

public static void speakToPerson2() {
    try {
      speakToPerson1();
    } catch (Exception e) {
      System.out.println("speakToPerson2 caused exception");
      e.printStackTrace();
      throw e;
    }
  }

  public static void speakToPerson3() {
    try {
      speakToPerson2();

    } catch (Exception e) {
      System.out.println("speakToPerson3 caused exception");
      e.printStackTrace();
      throw e;
    }
  }

Not really sure why you want to terminate the application after the exception is caught - wouldn't it be better to fix whatever went wrong?

In any case, in your catch block:

catch(Exception e) {
    e.printStackTrace(); //if you want it.
    //You could always just System.out.println("Exception occurred.");
    //Though the above is rather unspecific.
    System.exit(1);
}