If your exception extends java.lang.Exception, you must catch it (or rethrow). If it extends java.lang.RuntimeException, you are not required to do so. You will find that this is true for all standard exceptions as well.

edit Changed the words must not to not required to

You need to create a class that extends from Exception. It should look like this:

public class MyOwnException extends Exception {
    public MyOwnException () {

    }

    public MyOwnException (String message) {
        super (message);
    }

    public MyOwnException (Throwable cause) {
        super (cause);
    }

    public MyOwnException (String message, Throwable cause) {
        super (message, cause);
    }
}

Your question does not specify if this new exception should be checked or unchecked.

As you can see here, the two types are different:

• Checked exceptions are meant to flag a problematic situation that should be handled by the developer who calls your method. It should be possible to recover from such an exception. A good example of this is a FileNotFoundException. Those exceptions are subclasses of Exception.

• Unchecked exceptions are meant to represent a bug in your code, an unexpected situation that you might not be able to recover from. A NullPointerException is a classical example. Those exceptions are subclasses of RuntimeException

Checked exception must be handled by the calling method, either by catching it and acting accordingly, or by throwing it to the calling method. Unchecked exceptions are not meant to be caught, even though it is possible to do so.

If you don't want to force your code to wrap these methods in try blocks, why are you having them throw exceptions?

Let's consider these methods:

public void badMethodOne() throws CustomExceptionOne;
public void badMethodTwo() throws CustomExceptionTwo;

You're asking how you can avoid this scenario:

public void myMethod(){
   try{
      badMethodOne();
   }
   catch(CustomExceptionOne ex){
      ex.printStackTrace();
   }

   try{
      badMethodTwo();
   }
   catch(CustomExceptionTwo ex){
      ex.printStackTrace();
   }

}

One option would be to simply catch a superclass Exception:

public void myMethod(){
   try{
      badMethodOne();
      badMethodTwo();
   }
   catch(Exception ex){
      ex.printStackTrace();
   }

}

You might also use a multi-catch block:

public void myMethod(){
   try{
      badMethodOne();
      badMethodTwo();
   }
   catch(CustomExceptionOne | CustomExceptionTwo ex){
      ex.printStackTrace();
   }
}

You might also pass responsibility "up the chain" and let whoever's calling your code handle the try/catch:

public void myMethod() throws CustomExceptionOne, CustomExceptionTwo{
      badMethodOne();
      badMethodTwo();
}